OpenTTD Source 20241222-master-gc72542431a
town_cmd.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 "road.h"
12#include "road_internal.h" /* Cleaning up road bits */
13#include "road_cmd.h"
14#include "landscape.h"
15#include "viewport_func.h"
16#include "viewport_kdtree.h"
17#include "command_func.h"
18#include "company_func.h"
19#include "industry.h"
20#include "station_base.h"
21#include "waypoint_base.h"
22#include "station_kdtree.h"
23#include "company_base.h"
24#include "news_func.h"
25#include "error.h"
26#include "object.h"
27#include "genworld.h"
28#include "newgrf_debug.h"
29#include "newgrf_house.h"
30#include "newgrf_text.h"
31#include "autoslope.h"
32#include "tunnelbridge_map.h"
33#include "strings_func.h"
34#include "window_func.h"
35#include "string_func.h"
36#include "newgrf_cargo.h"
37#include "cheat_type.h"
38#include "animated_tile_func.h"
39#include "subsidy_func.h"
40#include "core/pool_func.hpp"
41#include "town.h"
42#include "town_kdtree.h"
43#include "townname_func.h"
44#include "core/random_func.hpp"
45#include "core/backup_type.hpp"
46#include "depot_base.h"
47#include "object_map.h"
48#include "object_base.h"
49#include "ai/ai.hpp"
50#include "game/game.hpp"
51#include "town_cmd.h"
52#include "landscape_cmd.h"
53#include "road_cmd.h"
54#include "terraform_cmd.h"
55#include "tunnelbridge_cmd.h"
56#include "timer/timer.h"
60
61#include "table/strings.h"
62#include "table/town_land.h"
63
64#include "safeguards.h"
65
66/* Initialize the town-pool */
67TownPool _town_pool("Town");
69
70
71TownKdtree _town_kdtree{};
72
73void RebuildTownKdtree()
74{
75 std::vector<TownID> townids;
76 for (const Town *town : Town::Iterate()) {
77 townids.push_back(town->index);
78 }
79 _town_kdtree.Build(townids.begin(), townids.end());
80}
81
83static bool _generating_town = false;
84
94static bool TestTownOwnsBridge(TileIndex tile, const Town *t)
95{
96 if (!IsTileOwner(tile, OWNER_TOWN)) return false;
97
99 bool town_owned = IsTileType(adjacent, MP_ROAD) && IsTileOwner(adjacent, OWNER_TOWN) && GetTownIndex(adjacent) == t->index;
100
101 if (!town_owned) {
102 /* Or other adjacent road */
104 town_owned = IsTileType(adjacent, MP_ROAD) && IsTileOwner(adjacent, OWNER_TOWN) && GetTownIndex(adjacent) == t->index;
105 }
106
107 return town_owned;
108}
109
111{
112 if (CleaningPool()) return;
113
114 /* Delete town authority window
115 * and remove from list of sorted towns */
117
118#ifdef WITH_ASSERT
119 /* Check no industry is related to us. */
120 for (const Industry *i : Industry::Iterate()) {
121 assert(i->town != this);
122 }
123
124 /* ... and no object is related to us. */
125 for (const Object *o : Object::Iterate()) {
126 assert(o->town != this);
127 }
128
129 /* Check no tile is related to us. */
130 for (const auto tile : Map::Iterate()) {
131 switch (GetTileType(tile)) {
132 case MP_HOUSE:
133 assert(GetTownIndex(tile) != this->index);
134 break;
135
136 case MP_ROAD:
137 assert(!HasTownOwnedRoad(tile) || GetTownIndex(tile) != this->index);
138 break;
139
140 case MP_TUNNELBRIDGE:
141 assert(!TestTownOwnsBridge(tile, this));
142 break;
143
144 default:
145 break;
146 }
147 }
148#endif /* WITH_ASSERT */
149
150 /* Clear the persistent storage list. */
151 for (auto &psa : this->psa_list) {
152 delete psa;
153 }
154 this->psa_list.clear();
155
160}
161
162
168{
169 InvalidateWindowData(WC_TOWN_DIRECTORY, 0, TDIWD_FORCE_REBUILD);
171
172 /* Give objects a new home! */
173 for (Object *o : Object::Iterate()) {
174 if (o->town == nullptr) o->town = CalcClosestTownFromTile(o->location.tile, UINT_MAX);
175 }
176}
177
183{
184 if (layout != TL_RANDOM) {
185 this->layout = layout;
186 return;
187 }
188
189 this->layout = static_cast<TownLayout>(TileHash(TileX(this->xy), TileY(this->xy)) % (NUM_TLS - 1));
190}
191
196/* static */ Town *Town::GetRandom()
197{
198 if (Town::GetNumItems() == 0) return nullptr;
199 int num = RandomRange((uint16_t)Town::GetNumItems());
200 size_t index = MAX_UVALUE(size_t);
201
202 while (num >= 0) {
203 num--;
204 index++;
205
206 /* Make sure we have a valid town */
207 while (!Town::IsValidID(index)) {
208 index++;
209 assert(index < Town::GetPoolSize());
210 }
211 }
212
213 return Town::Get(index);
214}
215
216void Town::FillCachedName() const
217{
218 this->cached_name = GetTownName(this);
219}
220
226{
227 return (_price[PR_CLEAR_HOUSE] * this->removal_cost) >> 8;
228}
229
230/* Local */
231static int _grow_town_result;
232
233/* The possible states of town growth. */
234enum TownGrowthResult {
235 GROWTH_SUCCEED = -1,
236 GROWTH_SEARCH_STOPPED = 0
237// GROWTH_SEARCH_RUNNING >= 1
238};
239
240static bool TryBuildTownHouse(Town *t, TileIndex tile);
241static Town *CreateRandomTown(uint attempts, uint32_t townnameparts, TownSize size, bool city, TownLayout layout);
242
243static void TownDrawHouseLift(const TileInfo *ti)
244{
245 AddChildSpriteScreen(SPR_LIFT, PAL_NONE, 14, 60 - GetLiftPosition(ti->tile));
246}
247
248typedef void TownDrawTileProc(const TileInfo *ti);
249static TownDrawTileProc * const _town_draw_tile_procs[1] = {
250 TownDrawHouseLift
251};
252
259{
261}
262
267static void DrawTile_Town(TileInfo *ti)
268{
269 HouseID house_id = GetHouseType(ti->tile);
270
271 if (house_id >= NEW_HOUSE_OFFSET) {
272 /* Houses don't necessarily need new graphics. If they don't have a
273 * spritegroup associated with them, then the sprite for the substitute
274 * house id is drawn instead. */
275 if (HouseSpec::Get(house_id)->grf_prop.spritegroup[0] != nullptr) {
276 DrawNewHouseTile(ti, house_id);
277 return;
278 } else {
279 house_id = HouseSpec::Get(house_id)->grf_prop.subst_id;
280 }
281 }
282
283 /* Retrieve pointer to the draw town tile struct */
284 const DrawBuildingsTileStruct *dcts = &_town_draw_tile_data[house_id << 4 | TileHash2Bit(ti->x, ti->y) << 2 | GetHouseBuildingStage(ti->tile)];
285
287
288 DrawGroundSprite(dcts->ground.sprite, dcts->ground.pal);
289
290 /* If houses are invisible, do not draw the upper part */
291 if (IsInvisibilitySet(TO_HOUSES)) return;
292
293 /* Add a house on top of the ground? */
294 SpriteID image = dcts->building.sprite;
295 if (image != 0) {
296 AddSortableSpriteToDraw(image, dcts->building.pal,
297 ti->x + dcts->subtile_x,
298 ti->y + dcts->subtile_y,
299 dcts->width,
300 dcts->height,
301 dcts->dz,
302 ti->z,
304 );
305
306 if (IsTransparencySet(TO_HOUSES)) return;
307 }
308
309 {
310 int proc = dcts->draw_proc - 1;
311
312 if (proc >= 0) _town_draw_tile_procs[proc](ti);
313 }
314}
315
316static int GetSlopePixelZ_Town(TileIndex tile, uint, uint, bool)
317{
318 return GetTileMaxPixelZ(tile);
319}
320
327{
328 HouseID hid = GetHouseType(tile);
329
330 /* For NewGRF house tiles we might not be drawing a foundation. We need to
331 * account for this, as other structures should
332 * draw the wall of the foundation in this case.
333 */
334 if (hid >= NEW_HOUSE_OFFSET) {
335 const HouseSpec *hs = HouseSpec::Get(hid);
336 if (hs->grf_prop.spritegroup[0] != nullptr && HasBit(hs->callback_mask, CBM_HOUSE_DRAW_FOUNDATIONS)) {
337 uint32_t callback_res = GetHouseCallback(CBID_HOUSE_DRAW_FOUNDATIONS, 0, 0, hid, Town::GetByTile(tile), tile);
338 if (callback_res != CALLBACK_FAILED && !ConvertBooleanCallback(hs->grf_prop.grffile, CBID_HOUSE_DRAW_FOUNDATIONS, callback_res)) return FOUNDATION_NONE;
339 }
340 }
341 return FlatteningFoundation(tileh);
342}
343
351{
352 if (GetHouseType(tile) >= NEW_HOUSE_OFFSET) {
353 AnimateNewHouseTile(tile);
354 return;
355 }
356
357 if (TimerGameTick::counter & 3) return;
358
359 /* If the house is not one with a lift anymore, then stop this animating.
360 * Not exactly sure when this happens, but probably when a house changes.
361 * Before this was just a return...so it'd leak animated tiles..
362 * That bug seems to have been here since day 1?? */
363 if (!(HouseSpec::Get(GetHouseType(tile))->building_flags & BUILDING_IS_ANIMATED)) {
364 DeleteAnimatedTile(tile);
365 return;
366 }
367
368 if (!LiftHasDestination(tile)) {
369 uint i;
370
371 /* Building has 6 floors, number 0 .. 6, where 1 is illegal.
372 * This is due to the fact that the first floor is, in the graphics,
373 * the height of 2 'normal' floors.
374 * Furthermore, there are 6 lift positions from floor N (incl) to floor N + 1 (excl) */
375 do {
376 i = RandomRange(7);
377 } while (i == 1 || i * 6 == GetLiftPosition(tile));
378
379 SetLiftDestination(tile, i);
380 }
381
382 int pos = GetLiftPosition(tile);
383 int dest = GetLiftDestination(tile) * 6;
384 pos += (pos < dest) ? 1 : -1;
385 SetLiftPosition(tile, pos);
386
387 if (pos == dest) {
388 HaltLift(tile);
389 DeleteAnimatedTile(tile);
390 }
391
393}
394
401static bool IsCloseToTown(TileIndex tile, uint dist)
402{
403 if (_town_kdtree.Count() == 0) return false;
404 Town *t = Town::Get(_town_kdtree.FindNearest(TileX(tile), TileY(tile)));
405 return DistanceManhattan(tile, t->xy) < dist;
406}
407
410{
411 Point pt = RemapCoords2(TileX(this->xy) * TILE_SIZE, TileY(this->xy) * TILE_SIZE);
412
413 if (this->cache.sign.kdtree_valid) _viewport_sign_kdtree.Remove(ViewportSignKdtreeItem::MakeTown(this->index));
414
415 SetDParam(0, this->index);
416 SetDParam(1, this->cache.population);
417 this->cache.sign.UpdatePosition(pt.x, pt.y - 24 * ZOOM_BASE,
418 _settings_client.gui.population_in_label ? STR_VIEWPORT_TOWN_POP : STR_VIEWPORT_TOWN,
419 STR_VIEWPORT_TOWN_TINY_WHITE);
420
421 _viewport_sign_kdtree.Insert(ViewportSignKdtreeItem::MakeTown(this->index));
422
424}
425
428{
429 for (Town *t : Town::Iterate()) {
430 t->UpdateVirtCoord();
431 }
432}
433
436{
437 for (Town *t : Town::Iterate()) {
438 t->cached_name.clear();
439 }
440}
441
447static void ChangePopulation(Town *t, int mod)
448{
449 t->cache.population += mod;
450 if (_generating_town) [[unlikely]] return;
451
452 InvalidateWindowData(WC_TOWN_VIEW, t->index); // Cargo requirements may appear/vanish for small populations
454
455 InvalidateWindowData(WC_TOWN_DIRECTORY, 0, TDIWD_POPULATION_CHANGE);
456}
457
463{
464 uint32_t pop = 0;
465 for (const Town *t : Town::Iterate()) pop += t->cache.population;
466 return pop;
467}
468
476static void RemoveNearbyStations(Town *t, TileIndex tile, BuildingFlags flags)
477{
478 for (StationList::iterator it = t->stations_near.begin(); it != t->stations_near.end(); /* incremented inside loop */) {
479 const Station *st = *it;
480
481 bool covers_area = st->TileIsInCatchment(tile);
482 if (flags & BUILDING_2_TILES_Y) covers_area |= st->TileIsInCatchment(tile + TileDiffXY(0, 1));
483 if (flags & BUILDING_2_TILES_X) covers_area |= st->TileIsInCatchment(tile + TileDiffXY(1, 0));
484 if (flags & BUILDING_HAS_4_TILES) covers_area |= st->TileIsInCatchment(tile + TileDiffXY(1, 1));
485
486 if (covers_area && !st->CatchmentCoversTown(t->index)) {
487 it = t->stations_near.erase(it);
488 } else {
489 ++it;
490 }
491 }
492}
493
499{
500 assert(IsTileType(tile, MP_HOUSE));
501
502 /* Progress in construction stages */
504 if (GetHouseConstructionTick(tile) != 0) return;
505
506 AnimateNewHouseConstruction(tile);
507
508 if (IsHouseCompleted(tile)) {
509 /* Now that construction is complete, we can add the population of the
510 * building to the town. */
511 ChangePopulation(Town::GetByTile(tile), HouseSpec::Get(GetHouseType(tile))->population);
512 ResetHouseAge(tile);
513 }
515}
516
522{
523 uint flags = HouseSpec::Get(GetHouseType(tile))->building_flags;
524 if (flags & BUILDING_HAS_1_TILE) AdvanceSingleHouseConstruction(TileAddXY(tile, 0, 0));
525 if (flags & BUILDING_2_TILES_Y) AdvanceSingleHouseConstruction(TileAddXY(tile, 0, 1));
526 if (flags & BUILDING_2_TILES_X) AdvanceSingleHouseConstruction(TileAddXY(tile, 1, 0));
527 if (flags & BUILDING_HAS_4_TILES) AdvanceSingleHouseConstruction(TileAddXY(tile, 1, 1));
528}
529
538static void TownGenerateCargo(Town *t, CargoID ct, uint amount, StationFinder &stations, bool affected_by_recession)
539{
540 if (amount == 0) return;
541
542 /* All production is halved during a recession (except for NewGRF-supplied town cargo). */
543 if (affected_by_recession && EconomyIsInRecession()) {
544 amount = (amount + 1) >> 1;
545 }
546
547 /* Scale by cargo scale setting. */
548 amount = ScaleByCargoScale(amount, true);
549
550 /* Actually generate cargo and update town statistics. */
551 t->supplied[ct].new_max += amount;
552 t->supplied[ct].new_act += MoveGoodsToStation(ct, amount, SourceType::Town, t->index, stations.GetStations());;
553}
554
562static void TownGenerateCargoOriginal(Town *t, TownProductionEffect tpe, uint8_t rate, StationFinder &stations)
563{
564 for (const CargoSpec *cs : CargoSpec::town_production_cargoes[tpe]) {
565 uint32_t r = Random();
566 if (GB(r, 0, 8) < rate) {
567 CargoID cid = cs->Index();
568 uint amt = (GB(r, 0, 8) * cs->town_production_multiplier / TOWN_PRODUCTION_DIVISOR) / 8 + 1;
569
570 TownGenerateCargo(t, cid, amt, stations, true);
571 }
572 }
573}
574
582static void TownGenerateCargoBinominal(Town *t, TownProductionEffect tpe, uint8_t rate, StationFinder &stations)
583{
584 for (const CargoSpec *cs : CargoSpec::town_production_cargoes[tpe]) {
585 CargoID cid = cs->Index();
586 uint32_t r = Random();
587
588 /* Make a bitmask with up to 32 bits set, one for each potential pax. */
589 int genmax = (rate + 7) / 8;
590 uint32_t genmask = (genmax >= 32) ? 0xFFFFFFFF : ((1 << genmax) - 1);
591
592 /* Mask random value by potential pax and count number of actual pax. */
593 uint amt = CountBits(r & genmask) * cs->town_production_multiplier / TOWN_PRODUCTION_DIVISOR;
594
595 TownGenerateCargo(t, cid, amt, stations, true);
596 }
597}
598
605static void TileLoop_Town(TileIndex tile)
606{
607 HouseID house_id = GetHouseType(tile);
608
609 /* NewHouseTileLoop returns false if Callback 21 succeeded, i.e. the house
610 * doesn't exist any more, so don't continue here. */
611 if (house_id >= NEW_HOUSE_OFFSET && !NewHouseTileLoop(tile)) return;
612
613 if (!IsHouseCompleted(tile)) {
614 /* Construction is not completed, so we advance a construction stage. */
616 return;
617 }
618
619 const HouseSpec *hs = HouseSpec::Get(house_id);
620
621 /* If the lift has a destination, it is already an animated tile. */
622 if ((hs->building_flags & BUILDING_IS_ANIMATED) &&
623 house_id < NEW_HOUSE_OFFSET &&
624 !LiftHasDestination(tile) &&
625 Chance16(1, 2)) {
626 AddAnimatedTile(tile);
627 }
628
629 Town *t = Town::GetByTile(tile);
630 uint32_t r = Random();
631
632 StationFinder stations(TileArea(tile, 1, 1));
633
635 for (uint i = 0; i < 256; i++) {
636 uint16_t callback = GetHouseCallback(CBID_HOUSE_PRODUCE_CARGO, i, r, house_id, t, tile);
637
638 if (callback == CALLBACK_FAILED || callback == CALLBACK_HOUSEPRODCARGO_END) break;
639
640 CargoID cargo = GetCargoTranslation(GB(callback, 8, 7), hs->grf_prop.grffile);
641 if (!IsValidCargoID(cargo)) continue;
642
643 uint amt = GB(callback, 0, 8);
644 if (amt == 0) continue;
645
646 /* NewGRF-supplied town cargos are not affected by recessions. */
647 TownGenerateCargo(t, cargo, amt, stations, false);
648 }
649 } else {
651 case TCGM_ORIGINAL:
652 /* Original (quadratic) cargo generation algorithm */
655 break;
656
657 case TCGM_BITCOUNT:
658 /* Binomial distribution per tick, by a series of coin flips */
659 /* Reduce generation rate to a 1/4, using tile bits to spread out distribution.
660 * As tick counter is incremented by 256 between each call, we ignore the lower 8 bits. */
661 if (GB(TimerGameTick::counter, 8, 2) == GB(tile.base(), 0, 2)) {
664 }
665 break;
666
667 default:
668 NOT_REACHED();
669 }
670 }
671
673
674 if ((hs->building_flags & BUILDING_HAS_1_TILE) &&
676 CanDeleteHouse(tile) &&
677 GetHouseAge(tile) >= hs->minimum_life &&
678 --t->time_until_rebuild == 0) {
679 t->time_until_rebuild = GB(r, 16, 8) + 192;
680
681 ClearTownHouse(t, tile);
682
683 /* Rebuild with another house? */
684 if (GB(r, 24, 8) >= 12) {
685 /* If we are multi-tile houses, make sure to replace the house
686 * closest to city center. If we do not do this, houses tend to
687 * wander away from roads and other houses. */
688 if (hs->building_flags & BUILDING_HAS_2_TILES) {
689 /* House tiles are always the most north tile. Move the new
690 * house to the south if we are north of the city center. */
691 TileIndexDiffC grid_pos = TileIndexToTileIndexDiffC(t->xy, tile);
692 int x = Clamp(grid_pos.x, 0, 1);
693 int y = Clamp(grid_pos.y, 0, 1);
694
695 if (hs->building_flags & TILE_SIZE_2x2) {
696 tile = TileAddXY(tile, x, y);
697 } else if (hs->building_flags & TILE_SIZE_1x2) {
698 tile = TileAddXY(tile, 0, y);
699 } else if (hs->building_flags & TILE_SIZE_2x1) {
700 tile = TileAddXY(tile, x, 0);
701 }
702 }
703
704 TryBuildTownHouse(t, tile);
705 }
706 }
707
708 cur_company.Restore();
709}
710
718{
719 if (flags & DC_AUTO) return CommandCost(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
720 if (!CanDeleteHouse(tile)) return CMD_ERROR;
721
722 const HouseSpec *hs = HouseSpec::Get(GetHouseType(tile));
723
725 cost.AddCost(hs->GetRemovalCost());
726
727 int rating = hs->remove_rating_decrease;
728 Town *t = Town::GetByTile(tile);
729
731 if (rating > t->ratings[_current_company] && !(flags & DC_NO_TEST_TOWN_RATING) &&
733 SetDParam(0, t->index);
734 return CommandCost(STR_ERROR_LOCAL_AUTHORITY_REFUSES_TO_ALLOW_THIS);
735 }
736 }
737
738 ChangeTownRating(t, -rating, RATING_HOUSE_MINIMUM, flags);
739 if (flags & DC_EXEC) {
740 ClearTownHouse(t, tile);
741 }
742
743 return cost;
744}
745
746static void AddProducedCargo_Town(TileIndex tile, CargoArray &produced)
747{
748 HouseID house_id = GetHouseType(tile);
749 const HouseSpec *hs = HouseSpec::Get(house_id);
750 Town *t = Town::GetByTile(tile);
751
753 for (uint i = 0; i < 256; i++) {
754 uint16_t callback = GetHouseCallback(CBID_HOUSE_PRODUCE_CARGO, i, 0, house_id, t, tile);
755
756 if (callback == CALLBACK_FAILED || callback == CALLBACK_HOUSEPRODCARGO_END) break;
757
758 CargoID cargo = GetCargoTranslation(GB(callback, 8, 7), hs->grf_prop.grffile);
759
760 if (!IsValidCargoID(cargo)) continue;
761 produced[cargo]++;
762 }
763 } else {
764 if (hs->population > 0) {
765 for (const CargoSpec *cs : CargoSpec::town_production_cargoes[TPE_PASSENGERS]) {
766 produced[cs->Index()]++;
767 }
768 }
769 if (hs->mail_generation > 0) {
770 for (const CargoSpec *cs : CargoSpec::town_production_cargoes[TPE_MAIL]) {
771 produced[cs->Index()]++;
772 }
773 }
774 }
775}
776
784static void AddAcceptedCargoSetMask(CargoID cargo, uint amount, CargoArray &acceptance, CargoTypes &always_accepted)
785{
786 if (!IsValidCargoID(cargo) || amount == 0) return;
787 acceptance[cargo] += amount;
788 SetBit(always_accepted, cargo);
789}
790
800void AddAcceptedCargoOfHouse(TileIndex tile, HouseID house, const HouseSpec *hs, Town *t, CargoArray &acceptance, CargoTypes &always_accepted)
801{
802 CargoID accepts[lengthof(hs->accepts_cargo)];
803
804 /* Set the initial accepted cargo types */
805 for (uint8_t i = 0; i < lengthof(accepts); i++) {
806 accepts[i] = hs->accepts_cargo[i];
807 }
808
809 /* Check for custom accepted cargo types */
811 uint16_t callback = GetHouseCallback(CBID_HOUSE_ACCEPT_CARGO, 0, 0, house, t, tile, tile == INVALID_TILE);
812 if (callback != CALLBACK_FAILED) {
813 /* Replace accepted cargo types with translated values from callback */
814 accepts[0] = GetCargoTranslation(GB(callback, 0, 5), hs->grf_prop.grffile);
815 accepts[1] = GetCargoTranslation(GB(callback, 5, 5), hs->grf_prop.grffile);
816 accepts[2] = GetCargoTranslation(GB(callback, 10, 5), hs->grf_prop.grffile);
817 }
818 }
819
820 /* Check for custom cargo acceptance */
822 uint16_t callback = GetHouseCallback(CBID_HOUSE_CARGO_ACCEPTANCE, 0, 0, house, t, tile, tile == INVALID_TILE);
823 if (callback != CALLBACK_FAILED) {
824 AddAcceptedCargoSetMask(accepts[0], GB(callback, 0, 4), acceptance, always_accepted);
825 AddAcceptedCargoSetMask(accepts[1], GB(callback, 4, 4), acceptance, always_accepted);
826 if (_settings_game.game_creation.landscape != LT_TEMPERATE && HasBit(callback, 12)) {
827 /* The 'S' bit indicates food instead of goods */
828 AddAcceptedCargoSetMask(GetCargoIDByLabel(CT_FOOD), GB(callback, 8, 4), acceptance, always_accepted);
829 } else {
830 AddAcceptedCargoSetMask(accepts[2], GB(callback, 8, 4), acceptance, always_accepted);
831 }
832 return;
833 }
834 }
835
836 /* No custom acceptance, so fill in with the default values */
837 for (uint8_t i = 0; i < lengthof(accepts); i++) {
838 AddAcceptedCargoSetMask(accepts[i], hs->cargo_acceptance[i], acceptance, always_accepted);
839 }
840}
841
842static void AddAcceptedCargo_Town(TileIndex tile, CargoArray &acceptance, CargoTypes &always_accepted)
843{
844 HouseID house = GetHouseType(tile);
845 AddAcceptedCargoOfHouse(tile, house, HouseSpec::Get(house), Town::GetByTile(tile), acceptance, always_accepted);
846}
847
854{
855 CargoTypes always_accepted;
856 CargoArray acceptance{};
857 AddAcceptedCargoOfHouse(INVALID_TILE, hs->Index(), hs, nullptr, acceptance, always_accepted);
858 return acceptance;
859}
860
861static void GetTileDesc_Town(TileIndex tile, TileDesc *td)
862{
863 const HouseID house = GetHouseType(tile);
864 const HouseSpec *hs = HouseSpec::Get(house);
865 bool house_completed = IsHouseCompleted(tile);
866
867 td->str = hs->building_name;
868
869 uint16_t callback_res = GetHouseCallback(CBID_HOUSE_CUSTOM_NAME, house_completed ? 1 : 0, 0, house, Town::GetByTile(tile), tile);
870 if (callback_res != CALLBACK_FAILED && callback_res != 0x400) {
871 if (callback_res > 0x400) {
873 } else {
874 StringID new_name = GetGRFStringID(hs->grf_prop.grfid, 0xD000 + callback_res);
875 if (new_name != STR_NULL && new_name != STR_UNDEFINED) {
876 td->str = new_name;
877 }
878 }
879 }
880
881 if (!house_completed) {
882 td->dparam = td->str;
883 td->str = STR_LAI_TOWN_INDUSTRY_DESCRIPTION_UNDER_CONSTRUCTION;
884 }
885
886 if (hs->grf_prop.HasGrfFile()) {
887 const GRFConfig *gc = GetGRFConfig(hs->grf_prop.grfid);
888 td->grf = gc->GetName();
889 }
890
891 td->owner[0] = OWNER_TOWN;
892}
893
894static TrackStatus GetTileTrackStatus_Town(TileIndex, TransportType, uint, DiagDirection)
895{
896 /* not used */
897 return 0;
898}
899
900static void ChangeTileOwner_Town(TileIndex, Owner, Owner)
901{
902 /* not used */
903}
904
905static bool GrowTown(Town *t);
906
911static void TownTickHandler(Town *t)
912{
913 if (HasBit(t->flags, TOWN_IS_GROWING)) {
914 int i = (int)t->grow_counter - 1;
915 if (i < 0) {
916 if (GrowTown(t)) {
917 i = t->growth_rate;
918 } else {
919 /* If growth failed wait a bit before retrying */
920 i = std::min<uint16_t>(t->growth_rate, Ticks::TOWN_GROWTH_TICKS - 1);
921 }
922 }
923 t->grow_counter = i;
924 }
925}
926
929{
930 if (_game_mode == GM_EDITOR) return;
931
932 for (Town *t : Town::Iterate()) {
934 }
935}
936
943{
944 if (IsRoadDepotTile(tile) || IsBayRoadStopTile(tile)) return ROAD_NONE;
945
946 return GetAnyRoadBits(tile, RTT_ROAD, true);
947}
948
954{
955 RoadType best_rt = ROADTYPE_ROAD;
956 const RoadTypeInfo *best = nullptr;
957 const uint16_t assume_max_speed = 50;
958
959 for (RoadType rt = ROADTYPE_BEGIN; rt != ROADTYPE_END; rt++) {
960 if (RoadTypeIsTram(rt)) continue;
961
962 const RoadTypeInfo *rti = GetRoadTypeInfo(rt);
963
964 /* Unused road type. */
965 if (rti->label == 0) continue;
966
967 /* Can town build this road. */
968 if (!HasBit(rti->flags, ROTF_TOWN_BUILD)) continue;
969
970 /* Not yet introduced at this date. */
972
973 if (best != nullptr) {
974 if ((rti->max_speed == 0 ? assume_max_speed : rti->max_speed) < (best->max_speed == 0 ? assume_max_speed : best->max_speed)) continue;
975 }
976
977 best_rt = rt;
978 best = rti;
979 }
980
981 return best_rt;
982}
983
988static TimerGameCalendar::Date GetTownRoadTypeFirstIntroductionDate()
989{
990 const RoadTypeInfo *best = nullptr;
991 for (RoadType rt = ROADTYPE_BEGIN; rt != ROADTYPE_END; rt++) {
992 if (RoadTypeIsTram(rt)) continue;
993 const RoadTypeInfo *rti = GetRoadTypeInfo(rt);
994 if (rti->label == 0) continue; // Unused road type.
995 if (!HasBit(rti->flags, ROTF_TOWN_BUILD)) continue; // Town can't build this road type.
996
997 if (best != nullptr && rti->introduction_date >= best->introduction_date) continue;
998 best = rti;
999 }
1000
1001 if (best == nullptr) return INT32_MAX;
1002 return best->introduction_date;
1003}
1004
1010{
1011 auto min_date = GetTownRoadTypeFirstIntroductionDate();
1012 if (min_date <= TimerGameCalendar::date) return true;
1013
1014 if (min_date < INT32_MAX) {
1015 SetDParam(0, min_date);
1016 ShowErrorMessage(STR_ERROR_NO_TOWN_ROADTYPES_AVAILABLE_YET, STR_ERROR_NO_TOWN_ROADTYPES_AVAILABLE_YET_EXPLANATION, WL_CRITICAL);
1017 } else {
1018 ShowErrorMessage(STR_ERROR_NO_TOWN_ROADTYPES_AVAILABLE_AT_ALL, STR_ERROR_NO_TOWN_ROADTYPES_AVAILABLE_AT_ALL_EXPLANATION, WL_CRITICAL);
1019 }
1020 return false;
1021}
1022
1033static bool IsNeighborRoadTile(TileIndex tile, const DiagDirection dir, uint dist_multi)
1034{
1035 if (!IsValidTile(tile)) return false;
1036
1037 /* Lookup table for the used diff values */
1038 const TileIndexDiff tid_lt[3] = {
1042 };
1043
1044 dist_multi = (dist_multi + 1) * 4;
1045 for (uint pos = 4; pos < dist_multi; pos++) {
1046 /* Go (pos / 4) tiles to the left or the right */
1047 TileIndexDiff cur = tid_lt[(pos & 1) ? 0 : 1] * (pos / 4);
1048
1049 /* Use the current tile as origin, or go one tile backwards */
1050 if (pos & 2) cur += tid_lt[2];
1051
1052 /* Test for roadbit parallel to dir and facing towards the middle axis */
1053 if (IsValidTile(tile + cur) &&
1054 GetTownRoadBits(TileAdd(tile, cur)) & DiagDirToRoadBits((pos & 2) ? dir : ReverseDiagDir(dir))) return true;
1055 }
1056 return false;
1057}
1058
1068{
1069 if (DistanceFromEdge(tile) == 0) return false;
1070
1071 /* Prevent towns from building roads under bridges along the bridge. Looks silly. */
1072 if (IsBridgeAbove(tile) && GetBridgeAxis(tile) == DiagDirToAxis(dir)) return false;
1073
1074 /* Check if there already is a road at this point? */
1075 if (GetTownRoadBits(tile) == ROAD_NONE) {
1076 /* No, try if we are able to build a road piece there.
1077 * If that fails clear the land, and if that fails exit.
1078 * This is to make sure that we can build a road here later. */
1080 if (Command<CMD_BUILD_ROAD>::Do(DC_AUTO | DC_NO_WATER, tile, (dir == DIAGDIR_NW || dir == DIAGDIR_SE) ? ROAD_Y : ROAD_X, rt, DRD_NONE, 0).Failed() &&
1082 return false;
1083 }
1084 }
1085
1086 Slope cur_slope = _settings_game.construction.build_on_slopes ? std::get<0>(GetFoundationSlope(tile)) : GetTileSlope(tile);
1087 bool ret = !IsNeighborRoadTile(tile, dir, t->layout == TL_ORIGINAL ? 1 : 2);
1088 if (cur_slope == SLOPE_FLAT) return ret;
1089
1090 /* If the tile is not a slope in the right direction, then
1091 * maybe terraform some. */
1092 Slope desired_slope = (dir == DIAGDIR_NW || dir == DIAGDIR_SE) ? SLOPE_NW : SLOPE_NE;
1093 if (desired_slope != cur_slope && ComplementSlope(desired_slope) != cur_slope) {
1094 if (Chance16(1, 8)) {
1095 CommandCost res = CMD_ERROR;
1096 if (!_generating_world && Chance16(1, 10)) {
1097 /* Note: Do not replace "^ SLOPE_ELEVATED" with ComplementSlope(). The slope might be steep. */
1099 tile, Chance16(1, 16) ? cur_slope : cur_slope ^ SLOPE_ELEVATED, false));
1100 }
1101 if (res.Failed() && Chance16(1, 3)) {
1102 /* We can consider building on the slope, though. */
1103 return ret;
1104 }
1105 }
1106 return false;
1107 }
1108 return ret;
1109}
1110
1111static bool TerraformTownTile(TileIndex tile, Slope edges, bool dir)
1112{
1113 assert(tile < Map::Size());
1114
1115 CommandCost r = std::get<0>(Command<CMD_TERRAFORM_LAND>::Do(DC_AUTO | DC_NO_WATER, tile, edges, dir));
1116 if (r.Failed() || r.GetCost() >= (_price[PR_TERRAFORM] + 2) * 8) return false;
1118 return true;
1119}
1120
1121static void LevelTownLand(TileIndex tile)
1122{
1123 assert(tile < Map::Size());
1124
1125 /* Don't terraform if land is plain or if there's a house there. */
1126 if (IsTileType(tile, MP_HOUSE)) return;
1127 Slope tileh = GetTileSlope(tile);
1128 if (tileh == SLOPE_FLAT) return;
1129
1130 /* First try up, then down */
1131 if (!TerraformTownTile(tile, ~tileh & SLOPE_ELEVATED, true)) {
1132 TerraformTownTile(tile, tileh & SLOPE_ELEVATED, false);
1133 }
1134}
1135
1145{
1146 /* align the grid to the downtown */
1147 TileIndexDiffC grid_pos = TileIndexToTileIndexDiffC(t->xy, tile); // Vector from downtown to the tile
1148 RoadBits rcmd = ROAD_NONE;
1149
1150 switch (t->layout) {
1151 default: NOT_REACHED();
1152
1153 case TL_2X2_GRID:
1154 if ((grid_pos.x % 3) == 0) rcmd |= ROAD_Y;
1155 if ((grid_pos.y % 3) == 0) rcmd |= ROAD_X;
1156 break;
1157
1158 case TL_3X3_GRID:
1159 if ((grid_pos.x % 4) == 0) rcmd |= ROAD_Y;
1160 if ((grid_pos.y % 4) == 0) rcmd |= ROAD_X;
1161 break;
1162 }
1163
1164 /* Optimise only X-junctions */
1165 if (rcmd != ROAD_ALL) return rcmd;
1166
1167 RoadBits rb_template;
1168
1169 switch (GetTileSlope(tile)) {
1170 default: rb_template = ROAD_ALL; break;
1171 case SLOPE_W: rb_template = ROAD_NW | ROAD_SW; break;
1172 case SLOPE_SW: rb_template = ROAD_Y | ROAD_SW; break;
1173 case SLOPE_S: rb_template = ROAD_SW | ROAD_SE; break;
1174 case SLOPE_SE: rb_template = ROAD_X | ROAD_SE; break;
1175 case SLOPE_E: rb_template = ROAD_SE | ROAD_NE; break;
1176 case SLOPE_NE: rb_template = ROAD_Y | ROAD_NE; break;
1177 case SLOPE_N: rb_template = ROAD_NE | ROAD_NW; break;
1178 case SLOPE_NW: rb_template = ROAD_X | ROAD_NW; break;
1179 case SLOPE_STEEP_W:
1180 case SLOPE_STEEP_S:
1181 case SLOPE_STEEP_E:
1182 case SLOPE_STEEP_N:
1183 rb_template = ROAD_NONE;
1184 break;
1185 }
1186
1187 /* Stop if the template is compatible to the growth dir */
1188 if (DiagDirToRoadBits(ReverseDiagDir(dir)) & rb_template) return rb_template;
1189 /* If not generate a straight road in the direction of the growth */
1191}
1192
1204{
1205 /* We can't look further than that. */
1206 if (DistanceFromEdge(tile) == 0) return false;
1207
1208 uint counter = 0; // counts the house neighbor tiles
1209
1210 /* Check the tiles E,N,W and S of the current tile for houses */
1211 for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) {
1212 /* Count both void and house tiles for checking whether there
1213 * are enough houses in the area. This to make it likely that
1214 * houses get build up to the edge of the map. */
1215 switch (GetTileType(TileAddByDiagDir(tile, dir))) {
1216 case MP_HOUSE:
1217 case MP_VOID:
1218 counter++;
1219 break;
1220
1221 default:
1222 break;
1223 }
1224
1225 /* If there are enough neighbors stop here */
1226 if (counter >= 3) {
1227 if (TryBuildTownHouse(t, tile)) {
1228 _grow_town_result = GROWTH_SUCCEED;
1229 return true;
1230 }
1231 return false;
1232 }
1233 }
1234 return false;
1235}
1236
1245static bool GrowTownWithRoad(const Town *t, TileIndex tile, RoadBits rcmd)
1246{
1248 if (Command<CMD_BUILD_ROAD>::Do(DC_EXEC | DC_AUTO | DC_NO_WATER, tile, rcmd, rt, DRD_NONE, t->index).Succeeded()) {
1249 _grow_town_result = GROWTH_SUCCEED;
1250 return true;
1251 }
1252 return false;
1253}
1254
1264static bool CanRoadContinueIntoNextTile(const Town *t, const TileIndex tile, const DiagDirection road_dir)
1265{
1266 const TileIndexDiff delta = TileOffsByDiagDir(road_dir); // +1 tile in the direction of the road
1267 TileIndex next_tile = tile + delta; // The tile beyond which must be connectable to the target tile
1268 RoadBits rcmd = DiagDirToRoadBits(ReverseDiagDir(road_dir));
1270
1271 /* Before we try anything, make sure the tile is on the map and not the void. */
1272 if (!IsValidTile(next_tile)) return false;
1273
1274 /* If the next tile is a bridge or tunnel, allow if it's continuing in the same direction. */
1275 if (IsTileType(next_tile, MP_TUNNELBRIDGE)) {
1276 return GetTunnelBridgeTransportType(next_tile) == TRANSPORT_ROAD && GetTunnelBridgeDirection(next_tile) == road_dir;
1277 }
1278
1279 /* If the next tile is a station, allow if it's a road station facing the proper direction. Otherwise return false. */
1280 if (IsTileType(next_tile, MP_STATION)) {
1281 /* If the next tile is a road station, allow if it can be entered by the new tunnel/bridge, otherwise disallow. */
1282 if (IsDriveThroughStopTile(next_tile)) return GetDriveThroughStopAxis(next_tile) == DiagDirToAxis(road_dir);
1283 if (IsBayRoadStopTile(next_tile)) return GetBayRoadStopDir(next_tile) == ReverseDiagDir(road_dir);
1284 return false;
1285 }
1286
1287 /* If the next tile is a road depot, allow if it's facing the right way. */
1288 if (IsTileType(next_tile, MP_ROAD)) {
1289 return IsRoadDepot(next_tile) && GetRoadDepotDirection(next_tile) == ReverseDiagDir(road_dir);
1290 }
1291
1292 /* If the next tile is a railroad track, check if towns are allowed to build level crossings.
1293 * If level crossing are not allowed, reject the construction. Else allow DoCommand to determine if the rail track is buildable. */
1294 if (IsTileType(next_tile, MP_RAILWAY) && !_settings_game.economy.allow_town_level_crossings) return false;
1295
1296 /* If a road tile can be built, the construction is allowed. */
1297 return Command<CMD_BUILD_ROAD>::Do(DC_AUTO | DC_NO_WATER, next_tile, rcmd, rt, DRD_NONE, t->index).Succeeded();
1298}
1299
1306static bool RedundantBridgeExistsNearby(TileIndex tile, void *user_data)
1307{
1308 /* Don't look into the void. */
1309 if (!IsValidTile(tile)) return false;
1310
1311 /* Only consider bridge head tiles. */
1312 if (!IsBridgeTile(tile)) return false;
1313
1314 /* Only consider road bridges. */
1315 if (GetTunnelBridgeTransportType(tile) != TRANSPORT_ROAD) return false;
1316
1317 /* If the bridge is facing the same direction as the proposed bridge, we've found a redundant bridge. */
1318 return (GetTileSlope(tile) & InclinedSlope(ReverseDiagDir(*(DiagDirection *)user_data)));
1319}
1320
1331static bool GrowTownWithBridge(const Town *t, const TileIndex tile, const DiagDirection bridge_dir)
1332{
1333 assert(bridge_dir < DIAGDIR_END);
1334
1335 const Slope slope = GetTileSlope(tile);
1336
1337 /* Make sure the direction is compatible with the slope.
1338 * Well we check if the slope has an up bit set in the
1339 * reverse direction. */
1340 if (slope != SLOPE_FLAT && slope & InclinedSlope(bridge_dir)) return false;
1341
1342 /* Assure that the bridge is connectable to the start side */
1343 if (!(GetTownRoadBits(TileAddByDiagDir(tile, ReverseDiagDir(bridge_dir))) & DiagDirToRoadBits(bridge_dir))) return false;
1344
1345 /* We are in the right direction */
1346 uint bridge_length = 0; // This value stores the length of the possible bridge
1347 TileIndex bridge_tile = tile; // Used to store the other waterside
1348
1349 const TileIndexDiff delta = TileOffsByDiagDir(bridge_dir);
1350
1351 /* To prevent really small towns from building disproportionately
1352 * long bridges, make the max a function of its population. */
1353 const uint TOWN_BRIDGE_LENGTH_CAP = 11;
1354 uint base_bridge_length = 5;
1355 uint max_bridge_length = std::min(t->cache.population / 1000 + base_bridge_length, TOWN_BRIDGE_LENGTH_CAP);
1356
1357 if (slope == SLOPE_FLAT) {
1358 /* Bridges starting on flat tiles are only allowed when crossing rivers, rails or one-way roads. */
1359 do {
1360 if (bridge_length++ >= base_bridge_length) {
1361 /* Allow to cross rivers, not big lakes, nor large amounts of rails or one-way roads. */
1362 return false;
1363 }
1364 bridge_tile += delta;
1365 } while (IsValidTile(bridge_tile) && ((IsWaterTile(bridge_tile) && !IsSea(bridge_tile)) || IsPlainRailTile(bridge_tile) || (IsNormalRoadTile(bridge_tile) && GetDisallowedRoadDirections(bridge_tile) != DRD_NONE)));
1366 } else {
1367 do {
1368 if (bridge_length++ >= max_bridge_length) {
1369 /* Ensure the bridge is not longer than the max allowed length. */
1370 return false;
1371 }
1372 bridge_tile += delta;
1373 } while (IsValidTile(bridge_tile) && (IsWaterTile(bridge_tile) || IsPlainRailTile(bridge_tile) || (IsNormalRoadTile(bridge_tile) && GetDisallowedRoadDirections(bridge_tile) != DRD_NONE)));
1374 }
1375
1376 /* Don't allow a bridge where the start and end tiles are adjacent with no span between. */
1377 if (bridge_length == 1) return false;
1378
1379 /* Make sure the road can be continued past the bridge. At this point, bridge_tile holds the end tile of the bridge. */
1380 if (!CanRoadContinueIntoNextTile(t, bridge_tile, bridge_dir)) return false;
1381
1382 /* If another parallel bridge exists nearby, this one would be redundant and shouldn't be built. We don't care about flat bridges. */
1383 TileIndex search = tile;
1384 DiagDirection direction_to_match = bridge_dir;
1385 if (slope != SLOPE_FLAT && CircularTileSearch(&search, bridge_length, 0, 0, RedundantBridgeExistsNearby, &direction_to_match)) return false;
1386
1387 for (uint8_t times = 0; times <= 22; times++) {
1388 uint8_t bridge_type = RandomRange(MAX_BRIDGES - 1);
1389
1390 /* Can we actually build the bridge? */
1392 if (Command<CMD_BUILD_BRIDGE>::Do(CommandFlagsToDCFlags(GetCommandFlags<CMD_BUILD_BRIDGE>()), tile, bridge_tile, TRANSPORT_ROAD, bridge_type, rt).Succeeded()) {
1393 Command<CMD_BUILD_BRIDGE>::Do(DC_EXEC | CommandFlagsToDCFlags(GetCommandFlags<CMD_BUILD_BRIDGE>()), tile, bridge_tile, TRANSPORT_ROAD, bridge_type, rt);
1394 _grow_town_result = GROWTH_SUCCEED;
1395 return true;
1396 }
1397 }
1398 /* Quit if it selecting an appropriate bridge type fails a large number of times. */
1399 return false;
1400}
1401
1412static bool GrowTownWithTunnel(const Town *t, const TileIndex tile, const DiagDirection tunnel_dir)
1413{
1414 assert(tunnel_dir < DIAGDIR_END);
1415
1416 Slope slope = GetTileSlope(tile);
1417
1418 /* Only consider building a tunnel if the starting tile is sloped properly. */
1419 if (slope != InclinedSlope(tunnel_dir)) return false;
1420
1421 /* Assure that the tunnel is connectable to the start side */
1422 if (!(GetTownRoadBits(TileAddByDiagDir(tile, ReverseDiagDir(tunnel_dir))) & DiagDirToRoadBits(tunnel_dir))) return false;
1423
1424 const TileIndexDiff delta = TileOffsByDiagDir(tunnel_dir);
1425 int max_tunnel_length = 0;
1426
1427 /* There are two conditions for building tunnels: Under a mountain and under an obstruction. */
1428 if (CanRoadContinueIntoNextTile(t, tile, tunnel_dir)) {
1429 /* Only tunnel under a mountain if the slope is continuous for at least 4 tiles. We want tunneling to be a last resort for large hills. */
1430 TileIndex slope_tile = tile;
1431 for (uint8_t tiles = 0; tiles < 4; tiles++) {
1432 if (!IsValidTile(slope_tile)) return false;
1433 slope = GetTileSlope(slope_tile);
1434 if (slope != InclinedSlope(tunnel_dir) && !IsSteepSlope(slope) && !IsSlopeWithOneCornerRaised(slope)) return false;
1435 slope_tile += delta;
1436 }
1437
1438 /* More population means longer tunnels, but make sure we can at least cover the smallest mountain which neccesitates tunneling. */
1439 max_tunnel_length = (t->cache.population / 1000) + 7;
1440 } else {
1441 /* When tunneling under an obstruction, the length limit is 5, enough to tunnel under a four-track railway. */
1442 max_tunnel_length = 5;
1443 }
1444
1445 uint8_t tunnel_length = 0;
1446 TileIndex tunnel_tile = tile; // Iteratator to store the other end tile of the tunnel.
1447
1448 /* Find the end tile of the tunnel for length and continuation checks. */
1449 do {
1450 if (tunnel_length++ >= max_tunnel_length) return false;
1451 tunnel_tile += delta;
1452 /* The tunnel ends when start and end tiles are the same height. */
1453 } while (IsValidTile(tunnel_tile) && GetTileZ(tile) != GetTileZ(tunnel_tile));
1454
1455 /* Don't allow a tunnel where the start and end tiles are adjacent. */
1456 if (tunnel_length == 1) return false;
1457
1458 /* Make sure the road can be continued past the tunnel. At this point, tunnel_tile holds the end tile of the tunnel. */
1459 if (!CanRoadContinueIntoNextTile(t, tunnel_tile, tunnel_dir)) return false;
1460
1461 /* Attempt to build the tunnel. Return false if it fails to let the town build a road instead. */
1463 if (Command<CMD_BUILD_TUNNEL>::Do(CommandFlagsToDCFlags(GetCommandFlags<CMD_BUILD_TUNNEL>()), tile, TRANSPORT_ROAD, rt).Succeeded()) {
1464 Command<CMD_BUILD_TUNNEL>::Do(DC_EXEC | CommandFlagsToDCFlags(GetCommandFlags<CMD_BUILD_TUNNEL>()), tile, TRANSPORT_ROAD, rt);
1465 _grow_town_result = GROWTH_SUCCEED;
1466 return true;
1467 }
1468
1469 return false;
1470}
1471
1479{
1480 static const TileIndexDiffC tiles[] = { {-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1} };
1481 bool allow = false;
1482
1483 for (const auto &ptr : tiles) {
1484 TileIndex cur_tile = t + ToTileIndexDiff(ptr);
1485 if (!IsValidTile(cur_tile)) continue;
1486
1487 if (!(IsTileType(cur_tile, MP_ROAD) || IsAnyRoadStopTile(cur_tile))) continue;
1488 allow = true;
1489
1490 RoadType road_rt = GetRoadTypeRoad(cur_tile);
1491 RoadType tram_rt = GetRoadTypeTram(cur_tile);
1492 if (road_rt != INVALID_ROADTYPE && !HasBit(GetRoadTypeInfo(road_rt)->flags, ROTF_NO_HOUSES)) return true;
1493 if (tram_rt != INVALID_ROADTYPE && !HasBit(GetRoadTypeInfo(tram_rt)->flags, ROTF_NO_HOUSES)) return true;
1494 }
1495
1496 /* If no road was found surrounding the tile we can allow building the house since there is
1497 * nothing which forbids it, if a road was found but the execution reached this point, then
1498 * all the found roads don't allow houses to be built */
1499 return !allow;
1500}
1501
1507{
1508 if (!IsTileType(tile, MP_ROAD)) return true;
1509
1510 /* Allow extending on roadtypes which can be built by town, or if the road type matches the type the town will build. */
1511 RoadType rt = GetRoadTypeRoad(tile);
1512 return HasBit(GetRoadTypeInfo(rt)->flags, ROTF_TOWN_BUILD) || GetTownRoadType() == rt;
1513}
1514
1519static inline bool TownAllowedToBuildRoads()
1520{
1521 return _settings_game.economy.allow_town_roads || _generating_world || _game_mode == GM_EDITOR;
1522}
1523
1541static void GrowTownInTile(TileIndex *tile_ptr, RoadBits cur_rb, DiagDirection target_dir, Town *t1)
1542{
1543 RoadBits rcmd = ROAD_NONE; // RoadBits for the road construction command
1544 TileIndex tile = *tile_ptr; // The main tile on which we base our growth
1545
1546 assert(tile < Map::Size());
1547
1548 if (cur_rb == ROAD_NONE) {
1549 /* Tile has no road. First reset the status counter
1550 * to say that this is the last iteration. */
1551 _grow_town_result = GROWTH_SEARCH_STOPPED;
1552
1553 if (!TownAllowedToBuildRoads()) return;
1555
1556 /* Remove hills etc */
1557 if (!_settings_game.construction.build_on_slopes || Chance16(1, 6)) LevelTownLand(tile);
1558
1559 /* Is a road allowed here? */
1560 switch (t1->layout) {
1561 default: NOT_REACHED();
1562
1563 case TL_3X3_GRID:
1564 case TL_2X2_GRID:
1565 rcmd = GetTownRoadGridElement(t1, tile, target_dir);
1566 if (rcmd == ROAD_NONE) return;
1567 break;
1568
1569 case TL_BETTER_ROADS:
1570 case TL_ORIGINAL:
1571 if (!IsRoadAllowedHere(t1, tile, target_dir)) return;
1572
1573 DiagDirection source_dir = ReverseDiagDir(target_dir);
1574
1575 if (Chance16(1, 4)) {
1576 /* Randomize a new target dir */
1577 do target_dir = RandomDiagDir(); while (target_dir == source_dir);
1578 }
1579
1580 if (!IsRoadAllowedHere(t1, TileAddByDiagDir(tile, target_dir), target_dir)) {
1581 /* A road is not allowed to continue the randomized road,
1582 * return if the road we're trying to build is curved. */
1583 if (target_dir != ReverseDiagDir(source_dir)) return;
1584
1585 /* Return if neither side of the new road is a house */
1588 return;
1589 }
1590
1591 /* That means that the road is only allowed if there is a house
1592 * at any side of the new road. */
1593 }
1594
1595 rcmd = DiagDirToRoadBits(target_dir) | DiagDirToRoadBits(source_dir);
1596 break;
1597 }
1598
1599 } else if (target_dir < DIAGDIR_END && !(cur_rb & DiagDirToRoadBits(ReverseDiagDir(target_dir)))) {
1600 if (!TownCanGrowRoad(tile)) return;
1601
1602 /* Continue building on a partial road.
1603 * Should be always OK, so we only generate
1604 * the fitting RoadBits */
1605 _grow_town_result = GROWTH_SEARCH_STOPPED;
1606
1607 if (!TownAllowedToBuildRoads()) return;
1608
1609 switch (t1->layout) {
1610 default: NOT_REACHED();
1611
1612 case TL_3X3_GRID:
1613 case TL_2X2_GRID:
1614 rcmd = GetTownRoadGridElement(t1, tile, target_dir);
1615 break;
1616
1617 case TL_BETTER_ROADS:
1618 case TL_ORIGINAL:
1619 rcmd = DiagDirToRoadBits(ReverseDiagDir(target_dir));
1620 break;
1621 }
1622 } else {
1623 bool allow_house = true; // Value which decides if we want to construct a house
1624
1625 /* Reached a tunnel/bridge? Then continue at the other side of it, unless
1626 * it is the starting tile. Half the time, we stay on this side then.*/
1627 if (IsTileType(tile, MP_TUNNELBRIDGE)) {
1628 if (GetTunnelBridgeTransportType(tile) == TRANSPORT_ROAD && (target_dir != DIAGDIR_END || Chance16(1, 2))) {
1629 *tile_ptr = GetOtherTunnelBridgeEnd(tile);
1630 }
1631 return;
1632 }
1633
1634 /* Possibly extend the road in a direction.
1635 * Randomize a direction and if it has a road, bail out. */
1636 target_dir = RandomDiagDir();
1637 RoadBits target_rb = DiagDirToRoadBits(target_dir);
1638 TileIndex house_tile; // position of a possible house
1639
1640 if (cur_rb & target_rb) {
1641 /* If it's a road turn possibly build a house in a corner.
1642 * Use intersection with straight road as an indicator
1643 * that we randomed corner house position.
1644 * A turn (and we check for that later) always has only
1645 * one common bit with a straight road so it has the same
1646 * chance to be chosen as the house on the side of a road.
1647 */
1648 if ((cur_rb & ROAD_X) != target_rb) return;
1649
1650 /* Check whether it is a turn and if so determine
1651 * position of the corner tile */
1652 switch (cur_rb) {
1653 case ROAD_N:
1654 house_tile = TileAddByDir(tile, DIR_S);
1655 break;
1656 case ROAD_S:
1657 house_tile = TileAddByDir(tile, DIR_N);
1658 break;
1659 case ROAD_E:
1660 house_tile = TileAddByDir(tile, DIR_W);
1661 break;
1662 case ROAD_W:
1663 house_tile = TileAddByDir(tile, DIR_E);
1664 break;
1665 default:
1666 return; // not a turn
1667 }
1668 target_dir = DIAGDIR_END;
1669 } else {
1670 house_tile = TileAddByDiagDir(tile, target_dir);
1671 }
1672
1673 /* Don't walk into water. */
1674 if (HasTileWaterGround(house_tile)) return;
1675
1676 if (!IsValidTile(house_tile)) return;
1677
1678 if (target_dir != DIAGDIR_END && TownAllowedToBuildRoads()) {
1679 switch (t1->layout) {
1680 default: NOT_REACHED();
1681
1682 case TL_3X3_GRID: // Use 2x2 grid afterwards!
1683 GrowTownWithExtraHouse(t1, TileAddByDiagDir(house_tile, target_dir));
1684 [[fallthrough]];
1685
1686 case TL_2X2_GRID:
1687 rcmd = GetTownRoadGridElement(t1, tile, target_dir);
1688 allow_house = (rcmd & target_rb) == ROAD_NONE;
1689 break;
1690
1691 case TL_BETTER_ROADS: // Use original afterwards!
1692 GrowTownWithExtraHouse(t1, TileAddByDiagDir(house_tile, target_dir));
1693 [[fallthrough]];
1694
1695 case TL_ORIGINAL:
1696 /* Allow a house at the edge. 60% chance or
1697 * always ok if no road allowed. */
1698 rcmd = target_rb;
1699 allow_house = (!IsRoadAllowedHere(t1, house_tile, target_dir) || Chance16(6, 10));
1700 break;
1701 }
1702 }
1703
1704 allow_house &= RoadTypesAllowHouseHere(house_tile);
1705
1706 if (allow_house) {
1707 /* Build a house, but not if there already is a house there. */
1708 if (!IsTileType(house_tile, MP_HOUSE)) {
1709 /* Level the land if possible */
1710 if (Chance16(1, 6)) LevelTownLand(house_tile);
1711
1712 /* And build a house.
1713 * Set result to -1 if we managed to build it. */
1714 if (TryBuildTownHouse(t1, house_tile)) {
1715 _grow_town_result = GROWTH_SUCCEED;
1716 }
1717 }
1718 return;
1719 }
1720
1721 if (!TownCanGrowRoad(tile)) return;
1722
1723 _grow_town_result = GROWTH_SEARCH_STOPPED;
1724 }
1725
1726 /* Return if a water tile */
1727 if (HasTileWaterGround(tile)) return;
1728
1729 /* Make the roads look nicer */
1730 rcmd = CleanUpRoadBits(tile, rcmd);
1731 if (rcmd == ROAD_NONE) return;
1732
1733 /* Only use the target direction for bridges and tunnels to ensure they're connected.
1734 * The target_dir is as computed previously according to town layout, so
1735 * it will match it perfectly. */
1736 if (GrowTownWithBridge(t1, tile, target_dir)) return;
1737 if (GrowTownWithTunnel(t1, tile, target_dir)) return;
1738
1739 GrowTownWithRoad(t1, tile, rcmd);
1740}
1741
1750{
1751 TileIndex target_tile = tile + TileOffsByDiagDir(dir);
1752 if (!IsValidTile(target_tile)) return false;
1753 if (HasTileWaterGround(target_tile)) return false;
1754
1755 RoadBits target_rb = GetTownRoadBits(target_tile);
1757 /* Check whether a road connection exists or can be build. */
1758 switch (GetTileType(target_tile)) {
1759 case MP_ROAD:
1760 return target_rb != ROAD_NONE;
1761
1762 case MP_STATION:
1763 return IsDriveThroughStopTile(target_tile);
1764
1765 case MP_TUNNELBRIDGE:
1766 return GetTunnelBridgeTransportType(target_tile) == TRANSPORT_ROAD;
1767
1768 case MP_HOUSE:
1769 case MP_INDUSTRY:
1770 case MP_OBJECT:
1771 return false;
1772
1773 default:
1774 /* Checked for void and water earlier */
1775 return true;
1776 }
1777 } else {
1778 /* Check whether a road connection already exists,
1779 * and it leads somewhere else. */
1781 return (target_rb & back_rb) != 0 && (target_rb & ~back_rb) != 0;
1782 }
1783}
1784
1791static bool GrowTownAtRoad(Town *t, TileIndex tile)
1792{
1793 /* Special case.
1794 * @see GrowTownInTile Check the else if
1795 */
1796 DiagDirection target_dir = DIAGDIR_END; // The direction in which we want to extend the town
1797
1798 assert(tile < Map::Size());
1799
1800 /* Number of times to search.
1801 * Better roads, 2X2 and 3X3 grid grow quite fast so we give
1802 * them a little handicap. */
1803 switch (t->layout) {
1804 case TL_BETTER_ROADS:
1805 _grow_town_result = 10 + t->cache.num_houses * 2 / 9;
1806 break;
1807
1808 case TL_3X3_GRID:
1809 case TL_2X2_GRID:
1810 _grow_town_result = 10 + t->cache.num_houses * 1 / 9;
1811 break;
1812
1813 default:
1814 _grow_town_result = 10 + t->cache.num_houses * 4 / 9;
1815 break;
1816 }
1817
1818 do {
1819 RoadBits cur_rb = GetTownRoadBits(tile); // The RoadBits of the current tile
1820
1821 /* Try to grow the town from this point */
1822 GrowTownInTile(&tile, cur_rb, target_dir, t);
1823 if (_grow_town_result == GROWTH_SUCCEED) return true;
1824
1825 /* Exclude the source position from the bitmask
1826 * and return if no more road blocks available */
1827 if (IsValidDiagDirection(target_dir)) cur_rb &= ~DiagDirToRoadBits(ReverseDiagDir(target_dir));
1828 if (cur_rb == ROAD_NONE) return false;
1829
1830 if (IsTileType(tile, MP_TUNNELBRIDGE)) {
1831 /* Only build in the direction away from the tunnel or bridge. */
1832 target_dir = ReverseDiagDir(GetTunnelBridgeDirection(tile));
1833 } else {
1834 /* Select a random bit from the blockmask, walk a step
1835 * and continue the search from there. */
1836 do {
1837 if (cur_rb == ROAD_NONE) return false;
1838 RoadBits target_bits;
1839 do {
1840 target_dir = RandomDiagDir();
1841 target_bits = DiagDirToRoadBits(target_dir);
1842 } while (!(cur_rb & target_bits));
1843 cur_rb &= ~target_bits;
1844 } while (!CanFollowRoad(tile, target_dir));
1845 }
1846 tile = TileAddByDiagDir(tile, target_dir);
1847
1848 if (IsTileType(tile, MP_ROAD) && !IsRoadDepot(tile) && HasTileRoadType(tile, RTT_ROAD)) {
1849 /* Don't allow building over roads of other cities */
1850 if (IsRoadOwner(tile, RTT_ROAD, OWNER_TOWN) && Town::GetByTile(tile) != t) {
1851 return false;
1852 } else if (IsRoadOwner(tile, RTT_ROAD, OWNER_NONE) && _game_mode == GM_EDITOR) {
1853 /* If we are in the SE, and this road-piece has no town owner yet, it just found an
1854 * owner :) (happy happy happy road now) */
1855 SetRoadOwner(tile, RTT_ROAD, OWNER_TOWN);
1856 SetTownIndex(tile, t->index);
1857 }
1858 }
1859
1860 /* Max number of times is checked. */
1861 } while (--_grow_town_result >= 0);
1862
1863 return false;
1864}
1865
1874{
1875 uint32_t r = Random();
1876 uint a = GB(r, 0, 2);
1877 uint b = GB(r, 8, 2);
1878 if (a == b) b ^= 2;
1879 return (RoadBits)((ROAD_NW << a) + (ROAD_NW << b));
1880}
1881
1887static bool GrowTown(Town *t)
1888{
1889 static const TileIndexDiffC _town_coord_mod[] = {
1890 {-1, 0},
1891 { 1, 1},
1892 { 1, -1},
1893 {-1, -1},
1894 {-1, 0},
1895 { 0, 2},
1896 { 2, 0},
1897 { 0, -2},
1898 {-1, -1},
1899 {-2, 2},
1900 { 2, 2},
1901 { 2, -2},
1902 { 0, 0}
1903 };
1904
1905 /* Current "company" is a town */
1907
1908 TileIndex tile = t->xy; // The tile we are working with ATM
1909
1910 /* Find a road that we can base the construction on. */
1911 for (const auto &ptr : _town_coord_mod) {
1912 if (GetTownRoadBits(tile) != ROAD_NONE) {
1913 bool success = GrowTownAtRoad(t, tile);
1914 cur_company.Restore();
1915 return success;
1916 }
1917 tile = TileAdd(tile, ToTileIndexDiff(ptr));
1918 }
1919
1920 /* No road available, try to build a random road block by
1921 * clearing some land and then building a road there. */
1923 tile = t->xy;
1924 for (const auto &ptr : _town_coord_mod) {
1925 /* Only work with plain land that not already has a house */
1926 if (!IsTileType(tile, MP_HOUSE) && IsTileFlat(tile)) {
1927 if (Command<CMD_LANDSCAPE_CLEAR>::Do(DC_AUTO | DC_NO_WATER, tile).Succeeded()) {
1930 cur_company.Restore();
1931 return true;
1932 }
1933 }
1934 tile = TileAdd(tile, ToTileIndexDiff(ptr));
1935 }
1936 }
1937
1938 cur_company.Restore();
1939 return false;
1940}
1941
1947{
1948 static const std::array<std::array<uint32_t, HZB_END>, 23> _town_squared_town_zone_radius_data = {{
1949 { 4, 0, 0, 0, 0}, // 0
1950 { 16, 0, 0, 0, 0},
1951 { 25, 0, 0, 0, 0},
1952 { 36, 0, 0, 0, 0},
1953 { 49, 0, 4, 0, 0},
1954 { 64, 0, 4, 0, 0}, // 20
1955 { 64, 0, 9, 0, 1},
1956 { 64, 0, 9, 0, 4},
1957 { 64, 0, 16, 0, 4},
1958 { 81, 0, 16, 0, 4},
1959 { 81, 0, 16, 0, 4}, // 40
1960 { 81, 0, 25, 0, 9},
1961 { 81, 36, 25, 0, 9},
1962 { 81, 36, 25, 16, 9},
1963 { 81, 49, 0, 25, 9},
1964 { 81, 64, 0, 25, 9}, // 60
1965 { 81, 64, 0, 36, 9},
1966 { 81, 64, 0, 36, 16},
1967 {100, 81, 0, 49, 16},
1968 {100, 81, 0, 49, 25},
1969 {121, 81, 0, 49, 25}, // 80
1970 {121, 81, 0, 49, 25},
1971 {121, 81, 0, 49, 36}, // 88
1972 }};
1973
1974 if (t->cache.num_houses < std::size(_town_squared_town_zone_radius_data) * 4) {
1975 t->cache.squared_town_zone_radius = _town_squared_town_zone_radius_data[t->cache.num_houses / 4];
1976 } else {
1977 int mass = t->cache.num_houses / 8;
1978 /* Actually we are proportional to sqrt() but that's right because we are covering an area.
1979 * The offsets are to make sure the radii do not decrease in size when going from the table
1980 * to the calculated value.*/
1981 t->cache.squared_town_zone_radius[HZB_TOWN_EDGE] = mass * 15 - 40;
1982 t->cache.squared_town_zone_radius[HZB_TOWN_OUTSKIRT] = mass * 9 - 15;
1983 t->cache.squared_town_zone_radius[HZB_TOWN_OUTER_SUBURB] = 0;
1984 t->cache.squared_town_zone_radius[HZB_TOWN_INNER_SUBURB] = mass * 5 - 5;
1985 t->cache.squared_town_zone_radius[HZB_TOWN_CENTRE] = mass * 3 + 5;
1986 }
1987}
1988
1994{
1996 t->supplied[cs->Index()].old_max = ScaleByCargoScale(t->cache.population >> 3, true);
1997 }
1999 t->supplied[cs->Index()].old_max = ScaleByCargoScale(t->cache.population >> 4, true);
2000 }
2001}
2002
2003static void UpdateTownGrowthRate(Town *t);
2004static void UpdateTownGrowth(Town *t);
2005
2017static void DoCreateTown(Town *t, TileIndex tile, uint32_t townnameparts, TownSize size, bool city, TownLayout layout, bool manual)
2018{
2019 AutoRestoreBackup backup(_generating_town, true);
2020
2021 t->xy = tile;
2022 t->cache.num_houses = 0;
2023 t->time_until_rebuild = 10;
2025 t->flags = 0;
2026 t->cache.population = 0;
2028 /* Spread growth across ticks so even if there are many
2029 * similar towns they're unlikely to grow all in one tick */
2031 t->growth_rate = TownTicksToGameTicks(250);
2032 t->show_zone = false;
2033
2034 _town_kdtree.Insert(t->index);
2035
2036 /* Set the default cargo requirement for town growth */
2038 case LT_ARCTIC:
2040 break;
2041
2042 case LT_TROPIC:
2045 break;
2046 }
2047
2048 t->fund_buildings_months = 0;
2049
2050 for (uint i = 0; i != MAX_COMPANIES; i++) t->ratings[i] = RATING_INITIAL;
2051
2052 t->have_ratings = 0;
2054 t->exclusive_counter = 0;
2055 t->statues = 0;
2056
2057 {
2059 t->townnamegrfid = tnp.grfid;
2060 t->townnametype = tnp.type;
2061 }
2062 t->townnameparts = townnameparts;
2063
2064 t->InitializeLayout(layout);
2065
2066 t->larger_town = city;
2067
2068 int x = (int)size * 16 + 3;
2069 if (size == TSZ_RANDOM) x = (Random() & 0xF) + 8;
2070 /* Don't create huge cities when founding town in-game */
2071 if (city && (!manual || _game_mode == GM_EDITOR)) x *= _settings_game.economy.initial_city_size;
2072
2073 t->cache.num_houses += x;
2075
2076 int i = x * 4;
2077 do {
2078 GrowTown(t);
2079 } while (--i);
2080
2081 t->UpdateVirtCoord();
2082 InvalidateWindowData(WC_TOWN_DIRECTORY, 0, TDIWD_FORCE_REBUILD);
2083
2084 t->cache.num_houses -= x;
2089}
2090
2097{
2098 /* Check if too close to the edge of map */
2099 if (DistanceFromEdge(tile) < 12) {
2100 return CommandCost(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP_SUB);
2101 }
2102
2103 /* Check distance to all other towns. */
2104 if (IsCloseToTown(tile, 20)) {
2105 return CommandCost(STR_ERROR_TOO_CLOSE_TO_ANOTHER_TOWN);
2106 }
2107
2108 /* Can only build on clear flat areas, possibly with trees. */
2109 if ((!IsTileType(tile, MP_CLEAR) && !IsTileType(tile, MP_TREES)) || !IsTileFlat(tile)) {
2110 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
2111 }
2112
2114}
2115
2121static bool IsUniqueTownName(const std::string &name)
2122{
2123 for (const Town *t : Town::Iterate()) {
2124 if (!t->name.empty() && t->name == name) return false;
2125 }
2126
2127 return true;
2128}
2129
2142std::tuple<CommandCost, Money, TownID> CmdFoundTown(DoCommandFlag flags, TileIndex tile, TownSize size, bool city, TownLayout layout, bool random_location, uint32_t townnameparts, const std::string &text)
2143{
2145
2146 if (size >= TSZ_END) return { CMD_ERROR, 0, INVALID_TOWN };
2147 if (layout >= NUM_TLS) return { CMD_ERROR, 0, INVALID_TOWN };
2148
2149 /* Some things are allowed only in the scenario editor and for game scripts. */
2150 if (_game_mode != GM_EDITOR && _current_company != OWNER_DEITY) {
2151 if (_settings_game.economy.found_town == TF_FORBIDDEN) return { CMD_ERROR, 0, INVALID_TOWN };
2152 if (size == TSZ_LARGE) return { CMD_ERROR, 0, INVALID_TOWN };
2153 if (random_location) return { CMD_ERROR, 0, INVALID_TOWN };
2155 return { CMD_ERROR, 0, INVALID_TOWN };
2156 }
2157 } else if (_current_company == OWNER_DEITY && random_location) {
2158 /* Random parameter is not allowed for Game Scripts. */
2159 return { CMD_ERROR, 0, INVALID_TOWN };
2160 }
2161
2162 if (text.empty()) {
2163 /* If supplied name is empty, townnameparts has to generate unique automatic name */
2164 if (!VerifyTownName(townnameparts, &par)) return { CommandCost(STR_ERROR_NAME_MUST_BE_UNIQUE), 0, INVALID_TOWN };
2165 } else {
2166 /* If name is not empty, it has to be unique custom name */
2167 if (Utf8StringLength(text) >= MAX_LENGTH_TOWN_NAME_CHARS) return { CMD_ERROR, 0, INVALID_TOWN };
2168 if (!IsUniqueTownName(text)) return { CommandCost(STR_ERROR_NAME_MUST_BE_UNIQUE), 0, INVALID_TOWN };
2169 }
2170
2171 /* Allocate town struct */
2172 if (!Town::CanAllocateItem()) return { CommandCost(STR_ERROR_TOO_MANY_TOWNS), 0, INVALID_TOWN };
2173
2174 if (!random_location) {
2175 CommandCost ret = TownCanBePlacedHere(tile);
2176 if (ret.Failed()) return { ret, 0, INVALID_TOWN };
2177 }
2178
2179 static const uint8_t price_mult[][TSZ_RANDOM + 1] = {{ 15, 25, 40, 25 }, { 20, 35, 55, 35 }};
2180 /* multidimensional arrays have to have defined length of non-first dimension */
2181 static_assert(lengthof(price_mult[0]) == 4);
2182
2183 CommandCost cost(EXPENSES_OTHER, _price[PR_BUILD_TOWN]);
2184 uint8_t mult = price_mult[city][size];
2185
2186 cost.MultiplyCost(mult);
2187
2188 /* Create the town */
2189 TownID new_town = INVALID_TOWN;
2190 if (flags & DC_EXEC) {
2191 if (cost.GetCost() > GetAvailableMoneyForCommand()) {
2192 return { CommandCost(EXPENSES_OTHER), cost.GetCost(), INVALID_TOWN };
2193 }
2194
2195 Backup<bool> old_generating_world(_generating_world, true);
2197 Town *t;
2198 if (random_location) {
2199 t = CreateRandomTown(20, townnameparts, size, city, layout);
2200 } else {
2201 t = new Town(tile);
2202 DoCreateTown(t, tile, townnameparts, size, city, layout, true);
2203 }
2204
2206 old_generating_world.Restore();
2207
2208 if (t == nullptr) return { CommandCost(STR_ERROR_NO_SPACE_FOR_TOWN), 0, INVALID_TOWN };
2209
2210 new_town = t->index;
2211
2212 if (!text.empty()) {
2213 t->name = text;
2214 t->UpdateVirtCoord();
2215 }
2216
2217 if (_game_mode != GM_EDITOR) {
2218 /* 't' can't be nullptr since 'random' is false outside scenedit */
2219 assert(!random_location);
2220
2222 SetDParam(0, t->index);
2223 AddTileNewsItem(STR_NEWS_NEW_TOWN_UNSPONSORED, NT_INDUSTRY_OPEN, tile);
2224 } else {
2226 std::string company_name = GetString(STR_COMPANY_NAME);
2227
2228 SetDParamStr(0, company_name);
2229 SetDParam(1, t->index);
2230
2231 AddTileNewsItem(STR_NEWS_NEW_TOWN, NT_INDUSTRY_OPEN, tile);
2232 }
2233 AI::BroadcastNewEvent(new ScriptEventTownFounded(t->index));
2234 Game::NewEvent(new ScriptEventTownFounded(t->index));
2235 }
2236 }
2237 return { cost, 0, new_town };
2238}
2239
2250{
2251 switch (layout) {
2252 case TL_2X2_GRID: return TileXY(TileX(tile) - TileX(tile) % 3, TileY(tile) - TileY(tile) % 3);
2253 case TL_3X3_GRID: return TileXY(TileX(tile) & ~3, TileY(tile) & ~3);
2254 default: return tile;
2255 }
2256}
2257
2268{
2269 switch (layout) {
2270 case TL_2X2_GRID: return TileX(tile) % 3 == 0 && TileY(tile) % 3 == 0;
2271 case TL_3X3_GRID: return TileX(tile) % 4 == 0 && TileY(tile) % 4 == 0;
2272 default: return true;
2273 }
2274}
2275
2284
2301static bool FindFurthestFromWater(TileIndex tile, void *user_data)
2302{
2303 SpotData *sp = (SpotData*)user_data;
2304 uint dist = GetClosestWaterDistance(tile, true);
2305
2306 if (IsTileType(tile, MP_CLEAR) &&
2307 IsTileFlat(tile) &&
2308 IsTileAlignedToGrid(tile, sp->layout) &&
2309 dist > sp->max_dist) {
2310 sp->tile = tile;
2311 sp->max_dist = dist;
2312 }
2313
2314 return false;
2315}
2316
2321static bool FindNearestEmptyLand(TileIndex tile, void *)
2322{
2323 return IsTileType(tile, MP_CLEAR);
2324}
2325
2339{
2340 SpotData sp = { INVALID_TILE, 0, layout };
2341
2342 TileIndex coast = tile;
2343 if (CircularTileSearch(&coast, 40, FindNearestEmptyLand, nullptr)) {
2344 CircularTileSearch(&coast, 10, FindFurthestFromWater, &sp);
2345 return sp.tile;
2346 }
2347
2348 /* if we get here just give up */
2349 return INVALID_TILE;
2350}
2351
2361static Town *CreateRandomTown(uint attempts, uint32_t townnameparts, TownSize size, bool city, TownLayout layout)
2362{
2363 assert(_game_mode == GM_EDITOR || _generating_world); // These are the preconditions for CMD_DELETE_TOWN
2364
2365 if (!Town::CanAllocateItem()) return nullptr;
2366
2367 do {
2368 /* Generate a tile index not too close from the edge */
2369 TileIndex tile = AlignTileToGrid(RandomTile(), layout);
2370
2371 /* if we tried to place the town on water, slide it over onto
2372 * the nearest likely-looking spot */
2373 if (IsTileType(tile, MP_WATER)) {
2374 tile = FindNearestGoodCoastalTownSpot(tile, layout);
2375 if (tile == INVALID_TILE) continue;
2376 }
2377
2378 /* Make sure town can be placed here */
2379 if (TownCanBePlacedHere(tile).Failed()) continue;
2380
2381 /* Allocate a town struct */
2382 Town *t = new Town(tile);
2383
2384 DoCreateTown(t, tile, townnameparts, size, city, layout, false);
2385
2386 /* if the population is still 0 at the point, then the
2387 * placement is so bad it couldn't grow at all */
2388 if (t->cache.population > 0) return t;
2389
2391 [[maybe_unused]] CommandCost rc = Command<CMD_DELETE_TOWN>::Do(DC_EXEC, t->index);
2392 cur_company.Restore();
2393 assert(rc.Succeeded());
2394
2395 /* We already know that we can allocate a single town when
2396 * entering this function. However, we create and delete
2397 * a town which "resets" the allocation checks. As such we
2398 * need to check again when assertions are enabled. */
2399 assert(Town::CanAllocateItem());
2400 } while (--attempts != 0);
2401
2402 return nullptr;
2403}
2404
2405static const uint8_t _num_initial_towns[4] = {5, 11, 23, 46}; // very low, low, normal, high
2406
2414{
2415 uint current_number = 0;
2416 uint difficulty = (_game_mode != GM_EDITOR) ? _settings_game.difficulty.number_towns : 0;
2417 uint total = (difficulty == (uint)CUSTOM_TOWN_NUMBER_DIFFICULTY) ? _settings_game.game_creation.custom_town_number : Map::ScaleBySize(_num_initial_towns[difficulty] + (Random() & 7));
2418 total = std::min<uint>(TownPool::MAX_SIZE, total);
2419 uint32_t townnameparts;
2420 TownNames town_names;
2421
2423
2424 /* Pre-populate the town names list with the names of any towns already on the map */
2425 for (const Town *town : Town::Iterate()) {
2426 town_names.insert(town->GetCachedName());
2427 }
2428
2429 /* Randomised offset for city status. This means with e.g. 1-in-4 towns being cities, a map with 10 towns
2430 * may have 2 or 3 cities, instead of always 3. */
2431 uint city_random_offset = _settings_game.economy.larger_towns == 0 ? 0 : (Random() % _settings_game.economy.larger_towns);
2432
2433 /* First attempt will be made at creating the suggested number of towns.
2434 * Note that this is really a suggested value, not a required one.
2435 * We would not like the system to lock up just because the user wanted 100 cities on a 64*64 map, would we? */
2436 do {
2437 bool city = (_settings_game.economy.larger_towns != 0 && ((city_random_offset + current_number) % _settings_game.economy.larger_towns) == 0);
2439 /* Get a unique name for the town. */
2440 if (!GenerateTownName(_random, &townnameparts, &town_names)) continue;
2441 /* try 20 times to create a random-sized town for the first loop. */
2442 if (CreateRandomTown(20, townnameparts, TSZ_RANDOM, city, layout) != nullptr) current_number++; // If creation was successful, raise a flag.
2443 } while (--total);
2444
2445 town_names.clear();
2446
2447 /* Build the town k-d tree again to make sure it's well balanced */
2448 RebuildTownKdtree();
2449
2450 if (current_number != 0) return true;
2451
2452 /* If current_number is still zero at this point, it means that not a single town has been created.
2453 * So give it a last try, but now more aggressive */
2454 if (GenerateTownName(_random, &townnameparts) &&
2455 CreateRandomTown(10000, townnameparts, TSZ_RANDOM, _settings_game.economy.larger_towns != 0, layout) != nullptr) {
2456 return true;
2457 }
2458
2459 /* If there are no towns at all and we are generating new game, bail out */
2460 if (Town::GetNumItems() == 0 && _game_mode != GM_EDITOR) {
2461 ShowErrorMessage(STR_ERROR_COULD_NOT_CREATE_TOWN, INVALID_STRING_ID, WL_CRITICAL);
2462 }
2463
2464 return false; // we are still without a town? we failed, simply
2465}
2466
2467
2474HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile)
2475{
2476 uint dist = DistanceSquare(tile, t->xy);
2477
2478 if (t->fund_buildings_months && dist <= 25) return HZB_TOWN_CENTRE;
2479
2480 HouseZonesBits smallest = HZB_TOWN_EDGE;
2481 for (HouseZonesBits i = HZB_BEGIN; i < HZB_END; i++) {
2482 if (dist < t->cache.squared_town_zone_radius[i]) smallest = i;
2483 }
2484
2485 return smallest;
2486}
2487
2498static inline void ClearMakeHouseTile(TileIndex tile, Town *t, uint8_t counter, uint8_t stage, HouseID type, uint8_t random_bits)
2499{
2501 assert(cc.Succeeded());
2502
2503 IncreaseBuildingCount(t, type);
2504 MakeHouseTile(tile, t->index, counter, stage, type, random_bits);
2505 if (HouseSpec::Get(type)->building_flags & BUILDING_IS_ANIMATED) AddAnimatedTile(tile, false);
2506
2507 MarkTileDirtyByTile(tile);
2508}
2509
2510
2521static void MakeTownHouse(TileIndex tile, Town *t, uint8_t counter, uint8_t stage, HouseID type, uint8_t random_bits)
2522{
2523 BuildingFlags size = HouseSpec::Get(type)->building_flags;
2524
2525 ClearMakeHouseTile(tile, t, counter, stage, type, random_bits);
2526 if (size & BUILDING_2_TILES_Y) ClearMakeHouseTile(tile + TileDiffXY(0, 1), t, counter, stage, ++type, random_bits);
2527 if (size & BUILDING_2_TILES_X) ClearMakeHouseTile(tile + TileDiffXY(1, 0), t, counter, stage, ++type, random_bits);
2528 if (size & BUILDING_HAS_4_TILES) ClearMakeHouseTile(tile + TileDiffXY(1, 1), t, counter, stage, ++type, random_bits);
2529
2530 ForAllStationsAroundTiles(TileArea(tile, (size & BUILDING_2_TILES_X) ? 2 : 1, (size & BUILDING_2_TILES_Y) ? 2 : 1), [t](Station *st, TileIndex) {
2531 t->stations_near.insert(st);
2532 return true;
2533 });
2534}
2535
2536
2543static inline bool CanBuildHouseHere(TileIndex tile, bool noslope)
2544{
2545 /* cannot build on these slopes... */
2546 Slope slope = GetTileSlope(tile);
2547 if ((noslope && slope != SLOPE_FLAT) || IsSteepSlope(slope)) return false;
2548
2549 /* at least one RoadTypes allow building the house here? */
2550 if (!RoadTypesAllowHouseHere(tile)) return false;
2551
2552 /* building under a bridge? */
2553 if (IsBridgeAbove(tile)) return false;
2554
2555 /* can we clear the land? */
2556 return Command<CMD_LANDSCAPE_CLEAR>::Do(DC_AUTO | DC_NO_WATER, tile).Succeeded();
2557}
2558
2559
2568static inline bool CheckBuildHouseSameZ(TileIndex tile, int z, bool noslope)
2569{
2570 if (!CanBuildHouseHere(tile, noslope)) return false;
2571
2572 /* if building on slopes is allowed, there will be flattening foundation (to tile max z) */
2573 if (GetTileMaxZ(tile) != z) return false;
2574
2575 return true;
2576}
2577
2578
2587static bool CheckFree2x2Area(TileIndex tile, int z, bool noslope)
2588{
2589 /* we need to check this tile too because we can be at different tile now */
2590 if (!CheckBuildHouseSameZ(tile, z, noslope)) return false;
2591
2592 for (DiagDirection d = DIAGDIR_SE; d < DIAGDIR_END; d++) {
2593 tile += TileOffsByDiagDir(d);
2594 if (!CheckBuildHouseSameZ(tile, z, noslope)) return false;
2595 }
2596
2597 return true;
2598}
2599
2600
2608static inline bool TownLayoutAllowsHouseHere(Town *t, TileIndex tile)
2609{
2610 /* Allow towns everywhere when we don't build roads */
2611 if (!TownAllowedToBuildRoads()) return true;
2612
2613 TileIndexDiffC grid_pos = TileIndexToTileIndexDiffC(t->xy, tile);
2614
2615 switch (t->layout) {
2616 case TL_2X2_GRID:
2617 if ((grid_pos.x % 3) == 0 || (grid_pos.y % 3) == 0) return false;
2618 break;
2619
2620 case TL_3X3_GRID:
2621 if ((grid_pos.x % 4) == 0 || (grid_pos.y % 4) == 0) return false;
2622 break;
2623
2624 default:
2625 break;
2626 }
2627
2628 return true;
2629}
2630
2631
2639static inline bool TownLayoutAllows2x2HouseHere(Town *t, TileIndex tile)
2640{
2641 /* Allow towns everywhere when we don't build roads */
2642 if (!TownAllowedToBuildRoads()) return true;
2643
2644 /* Compute relative position of tile. (Positive offsets are towards north) */
2645 TileIndexDiffC grid_pos = TileIndexToTileIndexDiffC(t->xy, tile);
2646
2647 switch (t->layout) {
2648 case TL_2X2_GRID:
2649 grid_pos.x %= 3;
2650 grid_pos.y %= 3;
2651 if ((grid_pos.x != 2 && grid_pos.x != -1) ||
2652 (grid_pos.y != 2 && grid_pos.y != -1)) return false;
2653 break;
2654
2655 case TL_3X3_GRID:
2656 if ((grid_pos.x & 3) < 2 || (grid_pos.y & 3) < 2) return false;
2657 break;
2658
2659 default:
2660 break;
2661 }
2662
2663 return true;
2664}
2665
2666
2676static bool CheckTownBuild2House(TileIndex *tile, Town *t, int maxz, bool noslope, DiagDirection second)
2677{
2678 /* 'tile' is already checked in BuildTownHouse() - CanBuildHouseHere() and slope test */
2679
2680 TileIndex tile2 = *tile + TileOffsByDiagDir(second);
2681 if (TownLayoutAllowsHouseHere(t, tile2) && CheckBuildHouseSameZ(tile2, maxz, noslope)) return true;
2682
2683 tile2 = *tile + TileOffsByDiagDir(ReverseDiagDir(second));
2684 if (TownLayoutAllowsHouseHere(t, tile2) && CheckBuildHouseSameZ(tile2, maxz, noslope)) {
2685 *tile = tile2;
2686 return true;
2687 }
2688
2689 return false;
2690}
2691
2692
2701static bool CheckTownBuild2x2House(TileIndex *tile, Town *t, int maxz, bool noslope)
2702{
2703 TileIndex tile2 = *tile;
2704
2705 for (DiagDirection d = DIAGDIR_SE;; d++) { // 'd' goes through DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_END
2706 if (TownLayoutAllows2x2HouseHere(t, tile2) && CheckFree2x2Area(tile2, maxz, noslope)) {
2707 *tile = tile2;
2708 return true;
2709 }
2710 if (d == DIAGDIR_END) break;
2711 tile2 += TileOffsByDiagDir(ReverseDiagDir(d)); // go clockwise
2712 }
2713
2714 return false;
2715}
2716
2725static void BuildTownHouse(Town *t, TileIndex tile, const HouseSpec *hs, HouseID house, uint8_t random_bits)
2726{
2727 /* build the house */
2728 t->cache.num_houses++;
2729
2730 uint8_t construction_counter = 0;
2731 uint8_t construction_stage = 0;
2732
2733 if (_generating_world || _game_mode == GM_EDITOR) {
2734 uint32_t construction_random = Random();
2735
2736 construction_stage = TOWN_HOUSE_COMPLETED;
2737 if (_generating_world && Chance16(1, 7)) construction_stage = GB(construction_random, 0, 2);
2738
2739 if (construction_stage == TOWN_HOUSE_COMPLETED) {
2741 } else {
2742 construction_counter = GB(construction_random, 2, 2);
2743 }
2744 }
2745
2746 MakeTownHouse(tile, t, construction_counter, construction_stage, house, random_bits);
2749}
2750
2757static bool TryBuildTownHouse(Town *t, TileIndex tile)
2758{
2759 /* forbidden building here by town layout */
2760 if (!TownLayoutAllowsHouseHere(t, tile)) return false;
2761
2762 /* no house allowed at all, bail out */
2763 if (!CanBuildHouseHere(tile, false)) return false;
2764
2765 Slope slope = GetTileSlope(tile);
2766 int maxz = GetTileMaxZ(tile);
2767
2768 /* Get the town zone type of the current tile, as well as the climate.
2769 * This will allow to easily compare with the specs of the new house to build */
2770 HouseZonesBits rad = GetTownRadiusGroup(t, tile);
2771
2772 /* Above snow? */
2774 if (land == LT_ARCTIC && maxz > HighestSnowLine()) land = -1;
2775
2776 uint bitmask = (1 << rad) + (1 << (land + 12));
2777
2778 /* bits 0-4 are used
2779 * bits 11-15 are used
2780 * bits 5-10 are not used. */
2781 static std::vector<std::pair<HouseID, uint>> probs;
2782 probs.clear();
2783
2784 uint probability_max = 0;
2785
2786 /* Generate a list of all possible houses that can be built. */
2787 for (const auto &hs : HouseSpec::Specs()) {
2788 /* Verify that the candidate house spec matches the current tile status */
2789 if ((~hs.building_availability & bitmask) != 0 || !hs.enabled || hs.grf_prop.override != INVALID_HOUSE_ID) continue;
2790
2791 /* Don't let these counters overflow. Global counters are 32bit, there will never be that many houses. */
2792 if (hs.class_id != HOUSE_NO_CLASS) {
2793 /* id_count is always <= class_count, so it doesn't need to be checked */
2794 if (t->cache.building_counts.class_count[hs.class_id] == UINT16_MAX) continue;
2795 } else {
2796 /* If the house has no class, check id_count instead */
2797 if (t->cache.building_counts.id_count[hs.Index()] == UINT16_MAX) continue;
2798 }
2799
2800 uint cur_prob = hs.probability;
2801 probability_max += cur_prob;
2802 probs.emplace_back(hs.Index(), cur_prob);
2803 }
2804
2805 TileIndex baseTile = tile;
2806
2807 while (probability_max > 0) {
2808 /* Building a multitile building can change the location of tile.
2809 * The building would still be built partially on that tile, but
2810 * its northern tile would be elsewhere. However, if the callback
2811 * fails we would be basing further work from the changed tile.
2812 * So a next 1x1 tile building could be built on the wrong tile. */
2813 tile = baseTile;
2814
2815 uint r = RandomRange(probability_max);
2816 uint i;
2817 for (i = 0; i < probs.size(); i++) {
2818 if (probs[i].second > r) break;
2819 r -= probs[i].second;
2820 }
2821
2822 HouseID house = probs[i].first;
2823 probability_max -= probs[i].second;
2824
2825 /* remove tested house from the set */
2826 probs[i] = probs.back();
2827 probs.pop_back();
2828
2829 const HouseSpec *hs = HouseSpec::Get(house);
2830
2831 if (!_generating_world && _game_mode != GM_EDITOR && (hs->extra_flags & BUILDING_IS_HISTORICAL) != 0) {
2832 continue;
2833 }
2834
2835 if (TimerGameCalendar::year < hs->min_year || TimerGameCalendar::year > hs->max_year) continue;
2836
2837 /* Special houses that there can be only one of. */
2838 uint oneof = 0;
2839
2840 if (hs->building_flags & BUILDING_IS_CHURCH) {
2841 SetBit(oneof, TOWN_HAS_CHURCH);
2842 } else if (hs->building_flags & BUILDING_IS_STADIUM) {
2843 SetBit(oneof, TOWN_HAS_STADIUM);
2844 }
2845
2846 if (t->flags & oneof) continue;
2847
2848 /* Make sure there is no slope? */
2849 bool noslope = (hs->building_flags & TILE_NOT_SLOPED) != 0;
2850 if (noslope && slope != SLOPE_FLAT) continue;
2851
2852 if (hs->building_flags & TILE_SIZE_2x2) {
2853 if (!CheckTownBuild2x2House(&tile, t, maxz, noslope)) continue;
2854 } else if (hs->building_flags & TILE_SIZE_2x1) {
2855 if (!CheckTownBuild2House(&tile, t, maxz, noslope, DIAGDIR_SW)) continue;
2856 } else if (hs->building_flags & TILE_SIZE_1x2) {
2857 if (!CheckTownBuild2House(&tile, t, maxz, noslope, DIAGDIR_SE)) continue;
2858 } else {
2859 /* 1x1 house checks are already done */
2860 }
2861
2862 uint8_t random_bits = Random();
2863
2865 uint16_t callback_res = GetHouseCallback(CBID_HOUSE_ALLOW_CONSTRUCTION, 0, 0, house, t, tile, true, random_bits);
2866 if (callback_res != CALLBACK_FAILED && !Convert8bitBooleanCallback(hs->grf_prop.grffile, CBID_HOUSE_ALLOW_CONSTRUCTION, callback_res)) continue;
2867 }
2868
2869 /* Special houses that there can be only one of. */
2870 t->flags |= oneof;
2871
2872 BuildTownHouse(t, tile, hs, house, random_bits);
2873
2874 return true;
2875 }
2876
2877 return false;
2878}
2879
2880CommandCost CmdPlaceHouse(DoCommandFlag flags, TileIndex tile, HouseID house)
2881{
2882 if (_game_mode != GM_EDITOR) return CMD_ERROR;
2883 if (Town::GetNumItems() == 0) return CommandCost(STR_ERROR_MUST_FOUND_TOWN_FIRST);
2884
2885 if (static_cast<size_t>(house) >= HouseSpec::Specs().size()) return CMD_ERROR;
2886 const HouseSpec *hs = HouseSpec::Get(house);
2887 if (!hs->enabled) return CMD_ERROR;
2888
2889 Town *t = ClosestTownFromTile(tile, UINT_MAX);
2890
2891 /* cannot build on these slopes... */
2892 Slope slope = GetTileSlope(tile);
2893 if (IsSteepSlope(slope)) return CommandCost(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
2894
2895 /* building under a bridge? */
2896 if (IsBridgeAbove(tile)) return CommandCost(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
2897
2898 /* can we clear the land? */
2900 if (!cost.Succeeded()) return cost;
2901
2902 int maxz = GetTileMaxZ(tile);
2903
2904 /* Make sure there is no slope? */
2905 bool noslope = (hs->building_flags & TILE_NOT_SLOPED) != 0;
2906 if (noslope && slope != SLOPE_FLAT) return CommandCost(STR_ERROR_FLAT_LAND_REQUIRED);
2907
2908 TileArea ta = tile;
2909 if (hs->building_flags & TILE_SIZE_2x2) ta.Add(TileAddXY(tile, 1, 1));
2910 if (hs->building_flags & TILE_SIZE_2x1) ta.Add(TileAddByDiagDir(tile, DIAGDIR_SW));
2911 if (hs->building_flags & TILE_SIZE_1x2) ta.Add(TileAddByDiagDir(tile, DIAGDIR_SE));
2912
2913 /* Check additonal tiles covered by this house. */
2914 for (const TileIndex &subtile : ta) {
2916 if (!cost.Succeeded()) return cost;
2917
2918 if (!CheckBuildHouseSameZ(subtile, maxz, noslope)) return CommandCost(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
2919 }
2920
2921 if (flags & DC_EXEC) {
2922 BuildTownHouse(t, tile, hs, house, Random());
2923 }
2924
2925 return CommandCost();
2926}
2927
2934static void DoClearTownHouseHelper(TileIndex tile, Town *t, HouseID house)
2935{
2936 assert(IsTileType(tile, MP_HOUSE));
2937 DecreaseBuildingCount(t, house);
2938 DoClearSquare(tile);
2939 DeleteAnimatedTile(tile);
2940
2941 DeleteNewGRFInspectWindow(GSF_HOUSES, tile.base());
2942}
2943
2952{
2953 if (house >= 3) { // house id 0,1,2 MUST be single tile houses, or this code breaks.
2954 if (HouseSpec::Get(house - 1)->building_flags & TILE_SIZE_2x1) {
2955 house--;
2956 return TileDiffXY(-1, 0);
2957 } else if (HouseSpec::Get(house - 1)->building_flags & BUILDING_2_TILES_Y) {
2958 house--;
2959 return TileDiffXY(0, -1);
2960 } else if (HouseSpec::Get(house - 2)->building_flags & BUILDING_HAS_4_TILES) {
2961 house -= 2;
2962 return TileDiffXY(-1, 0);
2963 } else if (HouseSpec::Get(house - 3)->building_flags & BUILDING_HAS_4_TILES) {
2964 house -= 3;
2965 return TileDiffXY(-1, -1);
2966 }
2967 }
2968 return TileDiffXY(0, 0);
2969}
2970
2977{
2978 assert(IsTileType(tile, MP_HOUSE));
2979
2980 HouseID house = GetHouseType(tile);
2981
2982 /* The northernmost tile of the house is the main house. */
2983 tile += GetHouseNorthPart(house);
2984
2985 const HouseSpec *hs = HouseSpec::Get(house);
2986
2987 /* Remove population from the town if the house is finished. */
2988 if (IsHouseCompleted(tile)) {
2990 }
2991
2992 t->cache.num_houses--;
2993
2994 /* Clear flags for houses that only may exist once/town. */
2995 if (hs->building_flags & BUILDING_IS_CHURCH) {
2997 } else if (hs->building_flags & BUILDING_IS_STADIUM) {
2999 }
3000
3001 /* Do the actual clearing of tiles */
3002 DoClearTownHouseHelper(tile, t, house);
3003 if (hs->building_flags & BUILDING_2_TILES_Y) DoClearTownHouseHelper(tile + TileDiffXY(0, 1), t, ++house);
3004 if (hs->building_flags & BUILDING_2_TILES_X) DoClearTownHouseHelper(tile + TileDiffXY(1, 0), t, ++house);
3005 if (hs->building_flags & BUILDING_HAS_4_TILES) DoClearTownHouseHelper(tile + TileDiffXY(1, 1), t, ++house);
3006
3008
3010}
3011
3019CommandCost CmdRenameTown(DoCommandFlag flags, TownID town_id, const std::string &text)
3020{
3021 Town *t = Town::GetIfValid(town_id);
3022 if (t == nullptr) return CMD_ERROR;
3023
3024 bool reset = text.empty();
3025
3026 if (!reset) {
3028 if (!IsUniqueTownName(text)) return CommandCost(STR_ERROR_NAME_MUST_BE_UNIQUE);
3029 }
3030
3031 if (flags & DC_EXEC) {
3032 t->cached_name.clear();
3033 if (reset) {
3034 t->name.clear();
3035 } else {
3036 t->name = text;
3037 }
3038
3039 t->UpdateVirtCoord();
3040 InvalidateWindowData(WC_TOWN_DIRECTORY, 0, TDIWD_FORCE_RESORT);
3041 ClearAllStationCachedNames();
3042 ClearAllIndustryCachedNames();
3044 }
3045 return CommandCost();
3046}
3047
3054{
3055 for (const CargoSpec *cs : CargoSpec::Iterate()) {
3056 if (cs->town_acceptance_effect == effect) return cs;
3057 }
3058 return nullptr;
3059}
3060
3069CommandCost CmdTownCargoGoal(DoCommandFlag flags, TownID town_id, TownAcceptanceEffect tae, uint32_t goal)
3070{
3071 if (_current_company != OWNER_DEITY) return CMD_ERROR;
3072
3073 if (tae < TAE_BEGIN || tae >= TAE_END) return CMD_ERROR;
3074
3075 Town *t = Town::GetIfValid(town_id);
3076 if (t == nullptr) return CMD_ERROR;
3077
3078 /* Validate if there is a cargo which is the requested TownEffect */
3080 if (cargo == nullptr) return CMD_ERROR;
3081
3082 if (flags & DC_EXEC) {
3083 t->goal[tae] = goal;
3086 }
3087
3088 return CommandCost();
3089}
3090
3098CommandCost CmdTownSetText(DoCommandFlag flags, TownID town_id, const std::string &text)
3099{
3100 if (_current_company != OWNER_DEITY) return CMD_ERROR;
3101 Town *t = Town::GetIfValid(town_id);
3102 if (t == nullptr) return CMD_ERROR;
3103
3104 if (flags & DC_EXEC) {
3105 t->text.clear();
3106 if (!text.empty()) t->text = text;
3108 }
3109
3110 return CommandCost();
3111}
3112
3120CommandCost CmdTownGrowthRate(DoCommandFlag flags, TownID town_id, uint16_t growth_rate)
3121{
3122 if (_current_company != OWNER_DEITY) return CMD_ERROR;
3123
3124 Town *t = Town::GetIfValid(town_id);
3125 if (t == nullptr) return CMD_ERROR;
3126
3127 if (flags & DC_EXEC) {
3128 if (growth_rate == 0) {
3129 /* Just clear the flag, UpdateTownGrowth will determine a proper growth rate */
3131 } else {
3132 uint old_rate = t->growth_rate;
3133 if (t->grow_counter >= old_rate) {
3134 /* This also catches old_rate == 0 */
3135 t->grow_counter = growth_rate;
3136 } else {
3137 /* Scale grow_counter, so half finished houses stay half finished */
3138 t->grow_counter = t->grow_counter * growth_rate / old_rate;
3139 }
3140 t->growth_rate = growth_rate;
3142 }
3145 }
3146
3147 return CommandCost();
3148}
3149
3158CommandCost CmdTownRating(DoCommandFlag flags, TownID town_id, CompanyID company_id, int16_t rating)
3159{
3160 if (_current_company != OWNER_DEITY) return CMD_ERROR;
3161
3162 Town *t = Town::GetIfValid(town_id);
3163 if (t == nullptr) return CMD_ERROR;
3164
3165 if (!Company::IsValidID(company_id)) return CMD_ERROR;
3166
3167 int16_t new_rating = Clamp(rating, RATING_MINIMUM, RATING_MAXIMUM);
3168 if (flags & DC_EXEC) {
3169 t->ratings[company_id] = new_rating;
3171 }
3172
3173 return CommandCost();
3174}
3175
3183CommandCost CmdExpandTown(DoCommandFlag flags, TownID town_id, uint32_t grow_amount)
3184{
3185 if (_game_mode != GM_EDITOR && _current_company != OWNER_DEITY) return CMD_ERROR;
3186 Town *t = Town::GetIfValid(town_id);
3187 if (t == nullptr) return CMD_ERROR;
3188
3189 if (flags & DC_EXEC) {
3190 /* The more houses, the faster we grow */
3191 if (grow_amount == 0) {
3192 uint amount = RandomRange(ClampTo<uint16_t>(t->cache.num_houses / 10)) + 3;
3193 t->cache.num_houses += amount;
3195
3196 uint n = amount * 10;
3197 do GrowTown(t); while (--n);
3198
3199 t->cache.num_houses -= amount;
3200 } else {
3201 for (; grow_amount > 0; grow_amount--) {
3202 /* Try several times to grow, as we are really suppose to grow */
3203 for (uint i = 0; i < 25; i++) if (GrowTown(t)) break;
3204 }
3205 }
3207
3209 }
3210
3211 return CommandCost();
3212}
3213
3221{
3222 if (_game_mode != GM_EDITOR && !_generating_world) return CMD_ERROR;
3223 Town *t = Town::GetIfValid(town_id);
3224 if (t == nullptr) return CMD_ERROR;
3225
3226 /* Stations refer to towns. */
3227 for (const Station *st : Station::Iterate()) {
3228 if (st->town == t) {
3229 /* Non-oil rig stations are always a problem. */
3230 if (!(st->facilities & FACIL_AIRPORT) || st->airport.type != AT_OILRIG) return CMD_ERROR;
3231 /* We can only automatically delete oil rigs *if* there's no vehicle on them. */
3232 CommandCost ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, st->airport.tile);
3233 if (ret.Failed()) return ret;
3234 }
3235 }
3236
3237 /* Waypoints refer to towns. */
3238 for (const Waypoint *wp : Waypoint::Iterate()) {
3239 if (wp->town == t) return CMD_ERROR;
3240 }
3241
3242 /* Depots refer to towns. */
3243 for (const Depot *d : Depot::Iterate()) {
3244 if (d->town == t) return CMD_ERROR;
3245 }
3246
3247 /* Check all tiles for town ownership. First check for bridge tiles, as
3248 * these do not directly have an owner so we need to check adjacent
3249 * tiles. This won't work correctly in the same loop if the adjacent
3250 * tile was already deleted earlier in the loop. */
3251 for (const auto current_tile : Map::Iterate()) {
3252 if (IsTileType(current_tile, MP_TUNNELBRIDGE) && TestTownOwnsBridge(current_tile, t)) {
3253 CommandCost ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, current_tile);
3254 if (ret.Failed()) return ret;
3255 }
3256 }
3257
3258 /* Check all remaining tiles for town ownership. */
3259 for (const auto current_tile : Map::Iterate()) {
3260 bool try_clear = false;
3261 switch (GetTileType(current_tile)) {
3262 case MP_ROAD:
3263 try_clear = HasTownOwnedRoad(current_tile) && GetTownIndex(current_tile) == t->index;
3264 break;
3265
3266 case MP_HOUSE:
3267 try_clear = GetTownIndex(current_tile) == t->index;
3268 break;
3269
3270 case MP_INDUSTRY:
3271 try_clear = Industry::GetByTile(current_tile)->town == t;
3272 break;
3273
3274 case MP_OBJECT:
3275 if (Town::GetNumItems() == 1) {
3276 /* No towns will be left, remove it! */
3277 try_clear = true;
3278 } else {
3279 Object *o = Object::GetByTile(current_tile);
3280 if (o->town == t) {
3281 if (o->type == OBJECT_STATUE) {
3282 /* Statue... always remove. */
3283 try_clear = true;
3284 } else {
3285 /* Tell to find a new town. */
3286 if (flags & DC_EXEC) o->town = nullptr;
3287 }
3288 }
3289 }
3290 break;
3291
3292 default:
3293 break;
3294 }
3295 if (try_clear) {
3296 CommandCost ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, current_tile);
3297 if (ret.Failed()) return ret;
3298 }
3299 }
3300
3301 /* The town destructor will delete the other things related to the town. */
3302 if (flags & DC_EXEC) {
3303 _town_kdtree.Remove(t->index);
3304 if (t->cache.sign.kdtree_valid) _viewport_sign_kdtree.Remove(ViewportSignKdtreeItem::MakeTown(t->index));
3305 delete t;
3306 }
3307
3308 return CommandCost();
3309}
3310
3316 2, 4, 9, 35, 48, 53, 117, 175
3317};
3318
3326{
3327 if (flags & DC_EXEC) {
3328 ModifyStationRatingAround(t->xy, _current_company, 0x40, 10);
3329 }
3330 return CommandCost();
3331}
3332
3340{
3341 if (flags & DC_EXEC) {
3342 ModifyStationRatingAround(t->xy, _current_company, 0x70, 15);
3343 }
3344 return CommandCost();
3345}
3346
3354{
3355 if (flags & DC_EXEC) {
3356 ModifyStationRatingAround(t->xy, _current_company, 0xA0, 20);
3357 }
3358 return CommandCost();
3359}
3360
3368{
3369 /* Check if the company is allowed to fund new roads. */
3371
3372 if (flags & DC_EXEC) {
3373 t->road_build_months = 6;
3374
3376 std::string company_name = GetString(STR_COMPANY_NAME);
3377
3378 SetDParam(0, t->index);
3379 SetDParamStr(1, company_name);
3380
3382 TimerGameEconomy::UsingWallclockUnits() ? STR_NEWS_ROAD_REBUILDING_MINUTES : STR_NEWS_ROAD_REBUILDING_MONTHS,
3383 NT_GENERAL, NF_NORMAL, NR_TOWN, t->index, NR_NONE, UINT32_MAX);
3384 AI::BroadcastNewEvent(new ScriptEventRoadReconstruction((ScriptCompany::CompanyID)(Owner)_current_company, t->index));
3385 Game::NewEvent(new ScriptEventRoadReconstruction((ScriptCompany::CompanyID)(Owner)_current_company, t->index));
3386 }
3387 return CommandCost();
3388}
3389
3395static bool CheckClearTile(TileIndex tile)
3396{
3399 cur_company.Restore();
3400 return r.Succeeded();
3401}
3402
3407
3408 StatueBuildSearchData(TileIndex best_pos, int count) : best_position(best_pos), tile_count(count) { }
3409};
3410
3417static bool SearchTileForStatue(TileIndex tile, void *user_data)
3418{
3419 static const int STATUE_NUMBER_INNER_TILES = 25; // Number of tiles int the center of the city, where we try to protect houses.
3420
3421 StatueBuildSearchData *statue_data = (StatueBuildSearchData *)user_data;
3422 statue_data->tile_count++;
3423
3424 /* Statues can be build on slopes, just like houses. Only the steep slopes is a no go. */
3425 if (IsSteepSlope(GetTileSlope(tile))) return false;
3426 /* Don't build statues under bridges. */
3427 if (IsBridgeAbove(tile)) return false;
3428
3429 /* A clear-able open space is always preferred. */
3430 if ((IsTileType(tile, MP_CLEAR) || IsTileType(tile, MP_TREES)) && CheckClearTile(tile)) {
3431 statue_data->best_position = tile;
3432 return true;
3433 }
3434
3435 bool house = IsTileType(tile, MP_HOUSE);
3436
3437 /* Searching inside the inner circle. */
3438 if (statue_data->tile_count <= STATUE_NUMBER_INNER_TILES) {
3439 /* Save first house in inner circle. */
3440 if (house && statue_data->best_position == INVALID_TILE && CheckClearTile(tile)) {
3441 statue_data->best_position = tile;
3442 }
3443
3444 /* If we have reached the end of the inner circle, and have a saved house, terminate the search. */
3445 return statue_data->tile_count == STATUE_NUMBER_INNER_TILES && statue_data->best_position != INVALID_TILE;
3446 }
3447
3448 /* Searching outside the circle, just pick the first possible spot. */
3449 statue_data->best_position = tile; // Is optimistic, the condition below must also hold.
3450 return house && CheckClearTile(tile);
3451}
3452
3461{
3462 if (!Object::CanAllocateItem()) return CommandCost(STR_ERROR_TOO_MANY_OBJECTS);
3463
3464 TileIndex tile = t->xy;
3465 StatueBuildSearchData statue_data(INVALID_TILE, 0);
3466 if (!CircularTileSearch(&tile, 9, SearchTileForStatue, &statue_data)) return CommandCost(STR_ERROR_STATUE_NO_SUITABLE_PLACE);
3467
3468 if (flags & DC_EXEC) {
3471 cur_company.Restore();
3473 SetBit(t->statues, _current_company); // Once found and built, "inform" the Town.
3475 }
3476 return CommandCost();
3477}
3478
3486{
3487 /* Check if it's allowed to buy the rights */
3489
3490 if (flags & DC_EXEC) {
3491 /* And grow for 3 months */
3492 t->fund_buildings_months = 3;
3493
3494 /* Enable growth (also checking GameScript's opinion) */
3496
3497 /* Build a new house, but add a small delay to make sure
3498 * that spamming funding doesn't let town grow any faster
3499 * than 1 house per 2 * TOWN_GROWTH_TICKS ticks.
3500 * Also emulate original behaviour when town was only growing in
3501 * TOWN_GROWTH_TICKS intervals, to make sure that it's not too
3502 * tick-perfect and gives player some time window where they can
3503 * spam funding with the exact same efficiency.
3504 */
3506
3508 }
3509 return CommandCost();
3510}
3511
3519{
3520 /* Check if it's allowed to buy the rights */
3522 if (t->exclusivity != INVALID_COMPANY) return CMD_ERROR;
3523
3524 if (flags & DC_EXEC) {
3525 t->exclusive_counter = 12;
3527
3528 ModifyStationRatingAround(t->xy, _current_company, 130, 17);
3529
3531
3532 /* Spawn news message */
3533 auto cni = std::make_unique<CompanyNewsInformation>(Company::Get(_current_company));
3534 SetDParam(0, STR_NEWS_EXCLUSIVE_RIGHTS_TITLE);
3535 SetDParam(1, TimerGameEconomy::UsingWallclockUnits() ? STR_NEWS_EXCLUSIVE_RIGHTS_DESCRIPTION_MINUTES : STR_NEWS_EXCLUSIVE_RIGHTS_DESCRIPTION_MONTHS);
3536 SetDParam(2, t->index);
3537 SetDParamStr(3, cni->company_name);
3538 AddNewsItem(STR_MESSAGE_NEWS_FORMAT, NT_GENERAL, NF_COMPANY, NR_TOWN, t->index, NR_NONE, UINT32_MAX, std::move(cni));
3539 AI::BroadcastNewEvent(new ScriptEventExclusiveTransportRights((ScriptCompany::CompanyID)(Owner)_current_company, t->index));
3540 Game::NewEvent(new ScriptEventExclusiveTransportRights((ScriptCompany::CompanyID)(Owner)_current_company, t->index));
3541 }
3542 return CommandCost();
3543}
3544
3552{
3553 if (flags & DC_EXEC) {
3554 if (Chance16(1, 14)) {
3555 /* set as unwanted for 6 months */
3556 t->unwanted[_current_company] = 6;
3557
3558 /* set all close by station ratings to 0 */
3559 for (Station *st : Station::Iterate()) {
3560 if (st->town == t && st->owner == _current_company) {
3561 for (GoodsEntry &ge : st->goods) ge.rating = 0;
3562 }
3563 }
3564
3565 /* only show error message to the executing player. All errors are handled command.c
3566 * but this is special, because it can only 'fail' on a DC_EXEC */
3567 if (IsLocalCompany()) ShowErrorMessage(STR_ERROR_BRIBE_FAILED, INVALID_STRING_ID, WL_INFO);
3568
3569 /* decrease by a lot!
3570 * ChangeTownRating is only for stuff in demolishing. Bribe failure should
3571 * be independent of any cheat settings
3572 */
3573 if (t->ratings[_current_company] > RATING_BRIBE_DOWN_TO) {
3574 t->ratings[_current_company] = RATING_BRIBE_DOWN_TO;
3576 }
3577 } else {
3578 ChangeTownRating(t, RATING_BRIBE_UP_STEP, RATING_BRIBE_MAXIMUM, DC_EXEC);
3581 t->exclusive_counter = 0;
3582 }
3583 }
3584 }
3585 return CommandCost();
3586}
3587
3588typedef CommandCost TownActionProc(Town *t, DoCommandFlag flags);
3589static TownActionProc * const _town_action_proc[] = {
3598};
3599
3607{
3608 TownActions buttons = TACT_NONE;
3609
3610 /* Spectators and unwanted have no options */
3611 if (cid != COMPANY_SPECTATOR && !(_settings_game.economy.bribe && t->unwanted[cid])) {
3612
3613 /* Actions worth more than this are not able to be performed */
3614 Money avail = GetAvailableMoney(cid);
3615
3616 /* Check the action bits for validity and
3617 * if they are valid add them */
3618 for (uint i = 0; i != lengthof(_town_action_costs); i++) {
3619 const TownActions cur = (TownActions)(1 << i);
3620
3621 /* Is the company prohibited from bribing ? */
3622 if (cur == TACT_BRIBE) {
3623 /* Company can't bribe if setting is disabled */
3624 if (!_settings_game.economy.bribe) continue;
3625 /* Company can bribe if another company has exclusive transport rights,
3626 * or its standing with the town is less than outstanding. */
3627 if (t->ratings[cid] >= RATING_BRIBE_MAXIMUM) {
3628 if (t->exclusivity == _current_company) continue;
3629 if (t->exclusive_counter == 0) continue;
3630 }
3631 }
3632
3633 /* Is the company not able to buy exclusive rights ? */
3634 if (cur == TACT_BUY_RIGHTS && (!_settings_game.economy.exclusive_rights || t->exclusive_counter != 0)) continue;
3635
3636 /* Is the company not able to fund buildings ? */
3638
3639 /* Is the company not able to fund local road reconstruction? */
3640 if (cur == TACT_ROAD_REBUILD && !_settings_game.economy.fund_roads) continue;
3641
3642 /* Is the company not able to build a statue ? */
3643 if (cur == TACT_BUILD_STATUE && HasBit(t->statues, cid)) continue;
3644
3645 if (avail >= _town_action_costs[i] * _price[PR_TOWN_ACTION] >> 8) {
3646 buttons |= cur;
3647 }
3648 }
3649 }
3650
3651 return buttons;
3652}
3653
3663CommandCost CmdDoTownAction(DoCommandFlag flags, TownID town_id, uint8_t action)
3664{
3665 Town *t = Town::GetIfValid(town_id);
3666 if (t == nullptr || action >= lengthof(_town_action_proc)) return CMD_ERROR;
3667
3668 if (!HasBit(GetMaskOfTownActions(_current_company, t), action)) return CMD_ERROR;
3669
3670 CommandCost cost(EXPENSES_OTHER, _price[PR_TOWN_ACTION] * _town_action_costs[action] >> 8);
3671
3672 CommandCost ret = _town_action_proc[action](t, flags);
3673 if (ret.Failed()) return ret;
3674
3675 if (flags & DC_EXEC) {
3677 }
3678
3679 return cost;
3680}
3681
3682template <typename Func>
3683static void ForAllStationsNearTown(Town *t, Func func)
3684{
3685 /* Ideally the search radius should be close to the actual town zone 0 radius.
3686 * The true radius is not stored or calculated anywhere, only the squared radius. */
3687 /* The efficiency of this search might be improved for large towns and many stations on the map,
3688 * by using an integer square root approximation giving a value not less than the true square root. */
3689 uint search_radius = t->cache.squared_town_zone_radius[HZB_TOWN_EDGE] / 2;
3690 ForAllStationsRadius(t->xy, search_radius, [&](const Station * st) {
3691 if (DistanceSquare(st->xy, t->xy) <= t->cache.squared_town_zone_radius[HZB_TOWN_EDGE]) {
3692 func(st);
3693 }
3694 });
3695}
3696
3701static void UpdateTownRating(Town *t)
3702{
3703 /* Increase company ratings if they're low */
3704 for (const Company *c : Company::Iterate()) {
3705 if (t->ratings[c->index] < RATING_GROWTH_MAXIMUM) {
3706 t->ratings[c->index] = std::min((int)RATING_GROWTH_MAXIMUM, t->ratings[c->index] + RATING_GROWTH_UP_STEP);
3707 }
3708 }
3709
3710 ForAllStationsNearTown(t, [&](const Station *st) {
3711 if (st->time_since_load <= 20 || st->time_since_unload <= 20) {
3712 if (Company::IsValidID(st->owner)) {
3713 int new_rating = t->ratings[st->owner] + RATING_STATION_UP_STEP;
3714 t->ratings[st->owner] = std::min<int>(new_rating, INT16_MAX); // do not let it overflow
3715 }
3716 } else {
3717 if (Company::IsValidID(st->owner)) {
3718 int new_rating = t->ratings[st->owner] + RATING_STATION_DOWN_STEP;
3719 t->ratings[st->owner] = std::max(new_rating, INT16_MIN);
3720 }
3721 }
3722 });
3723
3724 /* clamp all ratings to valid values */
3725 for (uint i = 0; i < MAX_COMPANIES; i++) {
3726 t->ratings[i] = Clamp(t->ratings[i], RATING_MINIMUM, RATING_MAXIMUM);
3727 }
3728
3730}
3731
3732
3739static void UpdateTownGrowCounter(Town *t, uint16_t prev_growth_rate)
3740{
3741 if (t->growth_rate == TOWN_GROWTH_RATE_NONE) return;
3742 if (prev_growth_rate == TOWN_GROWTH_RATE_NONE) {
3743 t->grow_counter = std::min<uint16_t>(t->growth_rate, t->grow_counter);
3744 return;
3745 }
3746 t->grow_counter = RoundDivSU((uint32_t)t->grow_counter * (t->growth_rate + 1), prev_growth_rate + 1);
3747}
3748
3755{
3756 int n = 0;
3757 ForAllStationsNearTown(t, [&](const Station * st) {
3758 if (st->time_since_load <= 20 || st->time_since_unload <= 20) {
3759 n++;
3760 }
3761 });
3762 return n;
3763}
3764
3772{
3778 static const uint16_t _grow_count_values[2][6] = {
3779 { 120, 120, 120, 100, 80, 60 }, // Fund new buildings has been activated
3780 { 320, 420, 300, 220, 160, 100 } // Normal values
3781 };
3782
3783 int n = CountActiveStations(t);
3784 uint16_t m = _grow_count_values[t->fund_buildings_months != 0 ? 0 : 1][std::min(n, 5)];
3785
3786 uint growth_multiplier = _settings_game.economy.town_growth_rate != 0 ? _settings_game.economy.town_growth_rate - 1 : 1;
3787
3788 m >>= growth_multiplier;
3789 if (t->larger_town) m /= 2;
3790
3791 return TownTicksToGameTicks(m / (t->cache.num_houses / 50 + 1));
3792}
3793
3799{
3800 if (HasBit(t->flags, TOWN_CUSTOM_GROWTH)) return;
3801 uint old_rate = t->growth_rate;
3803 UpdateTownGrowCounter(t, old_rate);
3805}
3806
3811static void UpdateTownGrowth(Town *t)
3812{
3814
3817
3819
3820 if (t->fund_buildings_months == 0) {
3821 /* Check if all goals are reached for this town to grow (given we are not funding it) */
3822 for (int i = TAE_BEGIN; i < TAE_END; i++) {
3823 switch (t->goal[i]) {
3824 case TOWN_GROWTH_WINTER:
3825 if (TileHeight(t->xy) >= GetSnowLine() && t->received[i].old_act == 0 && t->cache.population > 90) return;
3826 break;
3827 case TOWN_GROWTH_DESERT:
3828 if (GetTropicZone(t->xy) == TROPICZONE_DESERT && t->received[i].old_act == 0 && t->cache.population > 60) return;
3829 break;
3830 default:
3831 if (t->goal[i] > t->received[i].old_act) return;
3832 break;
3833 }
3834 }
3835 }
3836
3837 if (HasBit(t->flags, TOWN_CUSTOM_GROWTH)) {
3840 return;
3841 }
3842
3843 if (t->fund_buildings_months == 0 && CountActiveStations(t) == 0 && !Chance16(1, 12)) return;
3844
3847}
3848
3856{
3857 /* The required rating is hardcoded to RATING_VERYPOOR (see below), not the authority attitude setting, so we can bail out like this. */
3858 if (_settings_game.difficulty.town_council_tolerance == TOWN_COUNCIL_PERMISSIVE) return CommandCost();
3859
3861
3863 if (t == nullptr) return CommandCost();
3864
3865 if (t->ratings[_current_company] > RATING_VERYPOOR) return CommandCost();
3866
3867 SetDParam(0, t->index);
3868 return CommandCost(STR_ERROR_LOCAL_AUTHORITY_REFUSES_TO_ALLOW_THIS);
3869}
3870
3880{
3881 if (Town::GetNumItems() == 0) return nullptr;
3882
3883 TownID tid = _town_kdtree.FindNearest(TileX(tile), TileY(tile));
3884 Town *town = Town::Get(tid);
3885 if (DistanceManhattan(tile, town->xy) < threshold) return town;
3886 return nullptr;
3887}
3888
3897Town *ClosestTownFromTile(TileIndex tile, uint threshold)
3898{
3899 switch (GetTileType(tile)) {
3900 case MP_ROAD:
3901 if (IsRoadDepot(tile)) return CalcClosestTownFromTile(tile, threshold);
3902
3903 if (!HasTownOwnedRoad(tile)) {
3904 TownID tid = GetTownIndex(tile);
3905
3906 if (tid == INVALID_TOWN) {
3907 /* in the case we are generating "many random towns", this value may be INVALID_TOWN */
3908 if (_generating_world) return CalcClosestTownFromTile(tile, threshold);
3909 assert(Town::GetNumItems() == 0);
3910 return nullptr;
3911 }
3912
3913 assert(Town::IsValidID(tid));
3914 Town *town = Town::Get(tid);
3915
3916 if (DistanceManhattan(tile, town->xy) >= threshold) town = nullptr;
3917
3918 return town;
3919 }
3920 [[fallthrough]];
3921
3922 case MP_HOUSE:
3923 return Town::GetByTile(tile);
3924
3925 default:
3926 return CalcClosestTownFromTile(tile, threshold);
3927 }
3928}
3929
3930static bool _town_rating_test = false;
3931static std::map<const Town *, int> _town_test_ratings;
3932
3939{
3940 static int ref_count = 0; // Number of times test-mode is switched on.
3941 if (mode) {
3942 if (ref_count == 0) {
3943 _town_test_ratings.clear();
3944 }
3945 ref_count++;
3946 } else {
3947 assert(ref_count > 0);
3948 ref_count--;
3949 }
3950 _town_rating_test = !(ref_count == 0);
3951}
3952
3958static int GetRating(const Town *t)
3959{
3960 if (_town_rating_test) {
3961 auto it = _town_test_ratings.find(t);
3962 if (it != _town_test_ratings.end()) {
3963 return it->second;
3964 }
3965 }
3966 return t->ratings[_current_company];
3967}
3968
3976void ChangeTownRating(Town *t, int add, int max, DoCommandFlag flags)
3977{
3978 /* if magic_bulldozer cheat is active, town doesn't penalize for removing stuff */
3979 if (t == nullptr || (flags & DC_NO_MODIFY_TOWN_RATING) ||
3981 (_cheats.magic_bulldozer.value && add < 0)) {
3982 return;
3983 }
3984
3985 int rating = GetRating(t);
3986 if (add < 0) {
3987 if (rating > max) {
3988 rating += add;
3989 if (rating < max) rating = max;
3990 }
3991 } else {
3992 if (rating < max) {
3993 rating += add;
3994 if (rating > max) rating = max;
3995 }
3996 }
3997 if (_town_rating_test) {
3998 _town_test_ratings[t] = rating;
3999 } else {
4001 t->ratings[_current_company] = rating;
4003 }
4004}
4005
4014{
4015 /* if magic_bulldozer cheat is active, town doesn't restrict your destructive actions */
4016 if (t == nullptr || !Company::IsValidID(_current_company) ||
4018 return CommandCost();
4019 }
4020
4021 /* minimum rating needed to be allowed to remove stuff */
4022 static const int needed_rating[][TOWN_RATING_CHECK_TYPE_COUNT] = {
4023 /* ROAD_REMOVE, TUNNELBRIDGE_REMOVE */
4028 };
4029
4030 /* check if you're allowed to remove the road/bridge/tunnel
4031 * owned by a town no removal if rating is lower than ... depends now on
4032 * difficulty setting. Minimum town rating selected by difficulty level
4033 */
4034 int needed = needed_rating[_settings_game.difficulty.town_council_tolerance][type];
4035
4036 if (GetRating(t) < needed) {
4037 SetDParam(0, t->index);
4038 return CommandCost(STR_ERROR_LOCAL_AUTHORITY_REFUSES_TO_ALLOW_THIS);
4039 }
4040
4041 return CommandCost();
4042}
4043
4044static IntervalTimer<TimerGameEconomy> _economy_towns_monthly({TimerGameEconomy::MONTH, TimerGameEconomy::Priority::TOWN}, [](auto)
4045{
4046 for (Town *t : Town::Iterate()) {
4047 /* Check for active town actions and decrement their counters. */
4048 if (t->road_build_months != 0) t->road_build_months--;
4050
4051 if (t->exclusive_counter != 0) {
4052 if (--t->exclusive_counter == 0) t->exclusivity = INVALID_COMPANY;
4053 }
4054
4055 /* Check for active failed bribe cooloff periods and decrement them. */
4056 for (const Company *c : Company::Iterate()) {
4057 if (t->unwanted[c->index] > 0) t->unwanted[c->index]--;
4058 }
4059
4060 /* Update cargo statistics. */
4061 for (auto &supplied : t->supplied) supplied.NewMonth();
4062 for (auto &received : t->received) received.NewMonth();
4063
4066
4068 }
4069});
4070
4071static IntervalTimer<TimerGameEconomy> _economy_towns_yearly({TimerGameEconomy::YEAR, TimerGameEconomy::Priority::TOWN}, [](auto)
4072{
4073 /* Increment house ages */
4074 for (const auto t : Map::Iterate()) {
4075 if (!IsTileType(t, MP_HOUSE)) continue;
4077 }
4078});
4079
4080static CommandCost TerraformTile_Town(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)
4081{
4082 if (AutoslopeEnabled()) {
4083 HouseID house = GetHouseType(tile);
4084 GetHouseNorthPart(house); // modifies house to the ID of the north tile
4085 const HouseSpec *hs = HouseSpec::Get(house);
4086
4087 /* Here we differ from TTDP by checking TILE_NOT_SLOPED */
4088 if (((hs->building_flags & TILE_NOT_SLOPED) == 0) && !IsSteepSlope(tileh_new) &&
4089 (GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new))) {
4090 bool allow_terraform = true;
4091
4092 /* Call the autosloping callback per tile, not for the whole building at once. */
4093 house = GetHouseType(tile);
4094 hs = HouseSpec::Get(house);
4096 /* If the callback fails, allow autoslope. */
4097 uint16_t res = GetHouseCallback(CBID_HOUSE_AUTOSLOPE, 0, 0, house, Town::GetByTile(tile), tile);
4098 if (res != CALLBACK_FAILED && ConvertBooleanCallback(hs->grf_prop.grffile, CBID_HOUSE_AUTOSLOPE, res)) allow_terraform = false;
4099 }
4100
4101 if (allow_terraform) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
4102 }
4103 }
4104
4105 return Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
4106}
4107
4109extern const TileTypeProcs _tile_type_town_procs = {
4110 DrawTile_Town, // draw_tile_proc
4111 GetSlopePixelZ_Town, // get_slope_z_proc
4112 ClearTile_Town, // clear_tile_proc
4113 AddAcceptedCargo_Town, // add_accepted_cargo_proc
4114 GetTileDesc_Town, // get_tile_desc_proc
4115 GetTileTrackStatus_Town, // get_tile_track_status_proc
4116 nullptr, // click_tile_proc
4117 AnimateTile_Town, // animate_tile_proc
4118 TileLoop_Town, // tile_loop_proc
4119 ChangeTileOwner_Town, // change_tile_owner_proc
4120 AddProducedCargo_Town, // add_produced_cargo_proc
4121 nullptr, // vehicle_enter_tile_proc
4122 GetFoundation_Town, // get_foundation_proc
4123 TerraformTile_Town, // terraform_tile_proc
4124};
4125
4126std::span<const DrawBuildingsTileStruct> GetTownDrawTileData()
4127{
4128 return _town_draw_tile_data;
4129}
Base functions for all AIs.
@ AT_OILRIG
Oilrig airport.
Definition airport.h:38
void DeleteAnimatedTile(TileIndex tile)
Stops animation on the given tile.
void AddAnimatedTile(TileIndex tile, bool mark_dirty)
Add the given tile to the animated tile table (if it does not exist yet).
Tile animation!
Functions related to autoslope.
bool AutoslopeEnabled()
Tests if autoslope is enabled for _current_company.
Definition autoslope.h:65
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 uint CountBits(T value)
Counts the number of set bits in a variable.
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.
constexpr T ClrBit(T &x, const uint8_t y)
Clears a bit in a variable.
static const uint MAX_BRIDGES
Maximal number of available bridge specs.
Definition bridge.h:35
bool IsBridgeTile(Tile t)
checks if there is a bridge on this tile
Definition bridge_map.h:35
bool IsBridgeAbove(Tile t)
checks if a bridge is set above the ground of this tile
Definition bridge_map.h:45
Axis GetBridgeAxis(Tile t)
Get the axis of the bridge that goes over the tile.
Definition bridge_map.h:68
uint8_t CargoID
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:22
bool IsValidCargoID(CargoID t)
Test whether cargo type is not INVALID_CARGO.
Definition cargo_type.h:107
@ Town
Source/destination is a town.
TownProductionEffect
Town effect when producing cargo.
Definition cargotype.h:34
@ TPE_PASSENGERS
Cargo behaves passenger-like for production.
Definition cargotype.h:36
@ TPE_MAIL
Cargo behaves mail-like for production.
Definition cargotype.h:37
TownAcceptanceEffect
Town growth effect when delivering cargo.
Definition cargotype.h:21
@ TAE_END
End of town effects.
Definition cargotype.h:29
@ TAE_FOOD
Cargo behaves food/fizzy-drinks-like.
Definition cargotype.h:28
@ TAE_WATER
Cargo behaves water-like.
Definition cargotype.h:27
Cheats _cheats
All the cheats.
Definition cheat.cpp:16
Types related to cheating.
static void BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company=MAX_COMPANIES)
Broadcast a new event to all active AIs.
Definition ai_core.cpp:263
Common return value for all commands.
bool Succeeded() const
Did this command succeed?
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
Money GetCost() const
The costs as made up to this moment.
bool Failed() const
Did this command fail?
void MultiplyCost(int factor)
Multiplies the cost of the command by the given factor.
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
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:35
void Build(It begin, It end)
Clear and rebuild the tree from a new sequence of elements,.
Definition kdtree.hpp:362
size_t Count() const
Get number of elements stored in tree.
Definition kdtree.hpp:430
void Insert(const T &element)
Insert a single element in the tree.
Definition kdtree.hpp:398
void Remove(const T &element)
Remove a single element from the tree, if it exists.
Definition kdtree.hpp:417
T FindNearest(CoordT x, CoordT y) const
Find the element closest to given coordinate, in Manhattan distance.
Definition kdtree.hpp:441
RoadTypeLabel label
Unique 32 bit road type identifier.
Definition road.h:147
TimerGameCalendar::Date introduction_date
Introduction date.
Definition road.h:166
RoadTypeFlags flags
Bit mask of road type flags.
Definition road.h:127
uint16_t max_speed
Maximum speed for vehicles travelling on this road type.
Definition road.h:142
Structure contains cached list of stations nearby.
const StationList & GetStations()
Run a tile loop to find stations around a tile, on demand.
static constexpr TimerGameTick::Ticks TOWN_GROWTH_TICKS
Cycle duration for towns trying to grow (this originates from the size of the town array in TTD).
static Date date
Current date in days (day counter).
static Year year
Current year, starting at 0.
static constexpr TimerGame< struct Calendar >::Date MAX_DATE
The date of the last day of the max year.
static bool UsingWallclockUnits(bool newgame=false)
Check if we are using wallclock units.
static TickCounter counter
Monotonic counter, in ticks, since start of game.
Functions related to commands.
static constexpr DoCommandFlag CommandFlagsToDCFlags(CommandFlags cmd_flags)
Extracts the DC flags needed for DoCommand from the flags returned by GetCommandFlags.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
DoCommandFlag
List of flags for a command.
@ DC_NONE
no flag is set
@ DC_NO_TEST_TOWN_RATING
town rating does not disallow you from building
@ DC_AUTO
don't allow building on structures
@ DC_NO_WATER
don't allow building on water
@ DC_NO_MODIFY_TOWN_RATING
do not change town rating
@ DC_EXEC
execute the given command
Definition of stuff that is very close to a company, like the company struct itself.
Money GetAvailableMoneyForCommand()
This functions returns the money which can be used to execute a command.
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 _current_company
Company currently doing an action.
Functions related to companies.
bool IsLocalCompany()
Is the current company the local company?
Owner
Enum for all companies/owners.
@ INVALID_COMPANY
An invalid company.
@ COMPANY_SPECTATOR
The client is spectating.
@ OWNER_DEITY
The object is owned by a superuser / goal script.
@ OWNER_NONE
The tile has no ownership.
@ OWNER_TOWN
A town owns the tile, or a town is expanding.
@ MAX_COMPANIES
Maximum number of companies.
Base for all depots (except hangars)
DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
bool IsValidDiagDirection(DiagDirection d)
Checks if an integer value is a valid DiagDirection.
DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)
Applies a difference on a DiagDirection.
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
@ DIR_N
North.
@ DIR_S
South.
@ DIR_W
West.
@ DIR_E
East.
DiagDirection
Enumeration for diagonal directions.
@ DIAGDIR_NW
Northwest.
@ DIAGDIR_SE
Southeast.
@ DIAGDIR_END
Used for iterations.
@ DIAGDIR_BEGIN
Used for iterations.
@ DIAGDIR_SW
Southwest.
@ DIAGDIRDIFF_90RIGHT
90 degrees right
@ DIAGDIRDIFF_90LEFT
90 degrees left
bool EconomyIsInRecession()
Is the economy in recession?
uint ScaleByCargoScale(uint num, bool town)
Scale a number by the cargo scale setting.
@ EXPENSES_CONSTRUCTION
Construction costs.
@ EXPENSES_OTHER
Other expenses.
Functions related to errors.
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
Definition error.h:27
@ WL_INFO
Used for DoCommand-like (and some non-fatal AI GUI) errors/information.
Definition error.h:24
Base functions for all Games.
bool _generating_world
Whether we are generating the map or not.
Definition genworld.cpp:67
Functions related to world/map generation.
void IncreaseGeneratingWorldProgress(GenWorldProgress cls)
Increases the current stage of the world generation with one.
@ GWP_TOWN
Generate towns.
Definition genworld.h:74
void SetGeneratingWorldProgress(GenWorldProgress cls, uint total)
Set the total of a stage of the world generation.
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:18
uint8_t GetSnowLine()
Get the current snow line, either variable or static.
uint8_t HighestSnowLine()
Get the highest possible snow line height, either variable or static.
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition gfx.cpp:1529
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
static const HouseID NEW_HOUSE_OFFSET
Offset for new houses.
Definition house.h:26
static const uint8_t TOWN_HOUSE_COMPLETED
Simple value that indicates the house has reached the final stage of construction.
Definition house.h:23
@ BUILDING_IS_HISTORICAL
this house will only appear during town generation in random games, thus the historical
Definition house.h:85
uint16_t HouseID
OpenTTD ID of house types.
Definition house_type.h:13
Base of all industries.
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
std::tuple< Slope, int > GetFoundationSlope(TileIndex tile)
Get slope of a tile on top of a (possible) foundation If a tile does not have a foundation,...
Functions related to OTTD's landscape.
Point RemapCoords2(int x, int y)
Map 3D world or tile coordinate to equivalent 2D coordinate as used in the viewports and smallmap.
Definition landscape.h:95
Command definitions related to landscape (slopes etc.).
bool CircularTileSearch(TileIndex *tile, uint size, TestTileOnSearchProc proc, void *user_data)
Function performing a search around a center tile and going outward, thus in circle.
Definition map.cpp:247
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
Definition map.cpp:163
uint DistanceFromEdge(TileIndex tile)
Param the minimum distance to an edge.
Definition map.cpp:206
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition map.cpp:146
uint GetClosestWaterDistance(TileIndex tile, bool water)
Finds the distance for the closest tile with water/land given a tile.
Definition map.cpp:329
TileIndex TileAddXY(TileIndex tile, int x, int y)
Adds a given offset to a tile.
Definition map_func.h:467
TileIndex TileAddByDir(TileIndex tile, Direction dir)
Adds a Direction to a tile.
Definition map_func.h:596
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition map_func.h:373
TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
Return the offset between two tiles from a TileIndexDiffC struct.
Definition map_func.h:440
TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)
Adds a DiagDir to a tile.
Definition map_func.h:608
TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition map_func.h:389
constexpr TileIndex TileAdd(TileIndex tile, TileIndexDiff offset)
Adds a given offset to a tile.
Definition map_func.h:454
#define RandomTile()
Get a valid random tile.
Definition map_func.h:661
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:425
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:415
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition map_func.h:567
TileIndexDiffC TileIndexToTileIndexDiffC(TileIndex tile_a, TileIndex tile_b)
Returns the diff between two tiles.
Definition map_func.h:528
int32_t TileIndexDiff
An offset value between two tiles.
Definition map_type.h:23
constexpr int RoundDivSU(int a, uint b)
Computes round(a / b) for signed a and unsigned b.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition math_func.hpp:79
constexpr bool IsInsideMM(const T x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
@ GSF_FAKE_TOWNS
Fake town GrfSpecFeature for NewGRF debugging (parent scope)
Definition newgrf.h:91
@ CBID_HOUSE_DRAW_FOUNDATIONS
Called to determine the type (if any) of foundation to draw for house tile.
@ CBID_HOUSE_CARGO_ACCEPTANCE
Called to decide how much cargo a town building can accept.
@ CBID_HOUSE_AUTOSLOPE
Called to determine if one can alter the ground below a house tile.
@ CBID_HOUSE_CUSTOM_NAME
Called on the Get Tile Description for an house tile.
@ CBID_HOUSE_ALLOW_CONSTRUCTION
Determine whether the house can be built on the specified tile.
@ CBID_HOUSE_ACCEPT_CARGO
Called to determine which cargoes a town building should accept.
@ 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.
static const uint CALLBACK_HOUSEPRODCARGO_END
Sentinel indicating that the loop for CBID_HOUSE_PRODUCE_CARGO has ended.
@ CBM_HOUSE_PRODUCE_CARGO
custom cargo production
@ CBM_HOUSE_ALLOW_CONSTRUCTION
decide whether the house can be built on a given tile
@ CBM_HOUSE_CARGO_ACCEPTANCE
decides amount of cargo acceptance
@ CBM_HOUSE_AUTOSLOPE
decides allowance of autosloping
@ CBM_HOUSE_ACCEPT_CARGO
decides accepted types
@ CBM_HOUSE_DRAW_FOUNDATIONS
decides if default foundations need to be drawn
CargoID GetCargoTranslation(uint8_t cargo, const GRFFile *grffile, bool usebit)
Translate a GRF-local cargo slot/bitnum into a CargoID.
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.
bool Convert8bitBooleanCallback(const GRFFile *grffile, uint16_t cbid, uint16_t cb_res)
Converts a callback result into a boolean.
bool ConvertBooleanCallback(const GRFFile *grffile, uint16_t cbid, uint16_t cb_res)
Converts a callback result into a boolean.
GRFConfig * GetGRFConfig(uint32_t grfid, uint32_t mask)
Retrieve a NewGRF from the current config by its grfid.
Functions/types related to NewGRF debugging.
void DeleteNewGRFInspectWindow(GrfSpecFeature feature, uint index)
Delete inspect window for a given feature and index.
void DecreaseBuildingCount(Town *t, HouseID house_id)
DecreaseBuildingCount() Decrease the number of a building when it is deleted.
void IncreaseBuildingCount(Town *t, HouseID house_id)
IncreaseBuildingCount() Increase the count of a building when it has been added by a town.
void InitializeBuildingCounts()
Initialise global building counts and all town building counts.
Functions related to NewGRF houses.
StringID GetGRFStringID(uint32_t grfid, StringID stringid)
Returns the index for this stringid associated with its grfID.
Header of Action 04 "universal holder" structure and functions.
Functions related to news.
void AddNewsItem(StringID string, NewsType type, NewsFlag flags, NewsReferenceType reftype1=NR_NONE, uint32_t ref1=UINT32_MAX, NewsReferenceType reftype2=NR_NONE, uint32_t ref2=UINT32_MAX, std::unique_ptr< NewsAllocatedData > &&data=nullptr)
Add a new newsitem to be shown.
Definition news_gui.cpp:897
@ NT_INDUSTRY_OPEN
Opening of industries.
Definition news_type.h:29
@ NT_GENERAL
General news (from towns)
Definition news_type.h:39
@ NR_TOWN
Reference town. Scroll to town when clicking on the news.
Definition news_type.h:58
@ NR_NONE
Empty reference.
Definition news_type.h:53
@ NF_COMPANY
Company news item. (Newspaper with face)
Definition news_type.h:83
@ NF_NORMAL
Normal news item. (Newspaper with text only)
Definition news_type.h:81
Functions related to objects.
void BuildObject(ObjectType type, TileIndex tile, CompanyID owner=OWNER_NONE, struct Town *town=nullptr, uint8_t view=0)
Actually build the object.
Base for all objects.
Map accessors for object tiles.
static const ObjectType OBJECT_STATUE
Statue in towns.
Definition object_type.h:18
Some methods of Pool are placed here in order to reduce compilation time and binary size.
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
static debug_inline bool IsPlainRailTile(Tile t)
Checks whether the tile is a rail tile or rail tile with signals.
Definition rail_map.h:60
Randomizer _random
Random used in the game state calculations.
Pseudo random number generator.
uint32_t RandomRange(uint32_t limit, const std::source_location location=std::source_location::current())
Pick a random number between 0 and limit - 1, inclusive.
bool Chance16(const uint32_t a, const uint32_t b, const std::source_location location=std::source_location::current())
Flips a coin with given probability.
RoadBits CleanUpRoadBits(const TileIndex tile, RoadBits org_rb)
Clean up unnecessary RoadBits of a planned tile.
Definition road.cpp:47
Road specific functions.
@ ROTF_NO_HOUSES
Bit number for setting this roadtype as not house friendly.
Definition road.h:40
@ ROTF_TOWN_BUILD
Bit number for allowing towns to build this roadtype.
Definition road.h:42
const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
Definition road.h:227
void UpdateNearestTownForRoadTiles(bool invalidate)
Updates cached nearest town for all road tiles.
Road related functions.
RoadBits DiagDirToRoadBits(DiagDirection d)
Create the road-part which belongs to the given DiagDirection.
Definition road_func.h:96
Functions used internally by the roads.
RoadBits GetAnyRoadBits(Tile tile, RoadTramType rtt, bool straight_tunnel_bridge_entrance)
Returns the RoadBits on an arbitrary tile Special behaviour:
Definition road_map.cpp:33
void SetRoadOwner(Tile t, RoadTramType rtt, Owner o)
Set the owner of a specific road type.
Definition road_map.h:251
bool HasTownOwnedRoad(Tile t)
Checks if given tile has town owned road.
Definition road_map.h:280
static debug_inline bool IsNormalRoadTile(Tile t)
Return whether a tile is a normal road tile.
Definition road_map.h:74
static debug_inline bool IsRoadDepot(Tile t)
Return whether a tile is a road depot.
Definition road_map.h:106
DisallowedRoadDirections GetDisallowedRoadDirections(Tile t)
Gets the disallowed directions.
Definition road_map.h:301
bool HasTileRoadType(Tile t, RoadTramType rtt)
Check if a tile has a road or a tram road type.
Definition road_map.h:211
DiagDirection GetRoadDepotDirection(Tile t)
Get the direction of the exit of a road depot.
Definition road_map.h:565
static debug_inline bool IsRoadDepotTile(Tile t)
Return whether a tile is a road depot tile.
Definition road_map.h:116
bool IsRoadOwner(Tile t, RoadTramType rtt, Owner o)
Check if a specific road type is owned by an owner.
Definition road_map.h:268
RoadBits
Enumeration for the road parts on a tile.
Definition road_type.h:52
@ ROAD_SW
South-west part.
Definition road_type.h:55
@ ROAD_ALL
Full 4-way crossing.
Definition road_type.h:66
@ ROAD_NONE
No road-part is build.
Definition road_type.h:53
@ ROAD_E
Road at the two eastern edges.
Definition road_type.h:62
@ ROAD_NE
North-east part.
Definition road_type.h:57
@ ROAD_N
Road at the two northern edges.
Definition road_type.h:61
@ ROAD_SE
South-east part.
Definition road_type.h:56
@ ROAD_Y
Full road along the y-axis (north-west + south-east)
Definition road_type.h:59
@ ROAD_S
Road at the two southern edges.
Definition road_type.h:63
@ ROAD_W
Road at the two western edges.
Definition road_type.h:64
@ ROAD_NW
North-west part.
Definition road_type.h:54
@ ROAD_X
Full road along the x-axis (south-west + north-east)
Definition road_type.h:58
RoadType
The different roadtypes we support.
Definition road_type.h:25
@ INVALID_ROADTYPE
flag for invalid roadtype
Definition road_type.h:30
@ ROADTYPE_ROAD
Basic road type.
Definition road_type.h:27
@ ROADTYPE_END
Used for iterations.
Definition road_type.h:29
@ ROADTYPE_BEGIN
Used for iterations.
Definition road_type.h:26
@ DRD_NONE
None of the directions are disallowed.
Definition road_type.h:74
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:57
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:56
static constexpr int GetSlopeMaxZ(Slope s)
Returns the height of the highest corner of a slope relative to TileZ (= minimal height)
Definition slope_func.h:160
bool IsSlopeWithOneCornerRaised(Slope s)
Tests if a specific slope has exactly one corner raised.
Definition slope_func.h:88
static constexpr bool IsSteepSlope(Slope s)
Checks if a slope is steep.
Definition slope_func.h:36
Foundation FlatteningFoundation(Slope s)
Returns the foundation needed to flatten a slope.
Definition slope_func.h:369
Slope InclinedSlope(DiagDirection dir)
Returns the slope that is inclined in a specific direction.
Definition slope_func.h:256
Slope ComplementSlope(Slope s)
Return the complement of a slope.
Definition slope_func.h:76
Slope
Enumeration for the slope-type.
Definition slope_type.h:48
@ SLOPE_W
the west corner of the tile is raised
Definition slope_type.h:50
@ SLOPE_ELEVATED
bit mask containing all 'simple' slopes
Definition slope_type.h:61
@ SLOPE_E
the east corner of the tile is raised
Definition slope_type.h:52
@ SLOPE_S
the south corner of the tile is raised
Definition slope_type.h:51
@ SLOPE_N
the north corner of the tile is raised
Definition slope_type.h:53
@ SLOPE_SW
south and west corner are raised
Definition slope_type.h:56
@ SLOPE_FLAT
a flat tile
Definition slope_type.h:49
@ SLOPE_STEEP_W
a steep slope falling to east (from west)
Definition slope_type.h:66
@ SLOPE_NE
north and east corner are raised
Definition slope_type.h:58
@ SLOPE_STEEP_E
a steep slope falling to west (from east)
Definition slope_type.h:68
@ SLOPE_SE
south and east corner are raised
Definition slope_type.h:57
@ SLOPE_NW
north and west corner are raised
Definition slope_type.h:55
@ SLOPE_STEEP_N
a steep slope falling to south (from north)
Definition slope_type.h:69
@ SLOPE_STEEP_S
a steep slope falling to north (from south)
Definition slope_type.h:67
Foundation
Enumeration for Foundations.
Definition slope_type.h:93
@ FOUNDATION_LEVELED
The tile is leveled up to a flat slope.
Definition slope_type.h:95
@ FOUNDATION_NONE
The tile has no foundation, the slope remains unchanged.
Definition slope_type.h:94
Base classes/functions for stations.
void ForAllStationsAroundTiles(const TileArea &ta, Func func)
Call a function on all stations that have any part of the requested area within their catchment.
void UpdateAllStationVirtCoords()
Update the virtual coords needed to draw the station sign for all stations.
void UpdateAirportsNoise()
Recalculate the noise generated by the airports of each town.
Declarations for accessing the k-d tree of stations.
void ForAllStationsRadius(TileIndex center, uint radius, Func func)
Call a function on all stations whose sign is within a radius of a center tile.
bool IsBayRoadStopTile(Tile t)
Is tile t a bay (non-drive through) road stop station?
bool IsDriveThroughStopTile(Tile t)
Is tile t a drive through road stop station or waypoint?
Axis GetDriveThroughStopAxis(Tile t)
Gets the axis of the drive through stop.
DiagDirection GetBayRoadStopDir(Tile t)
Gets the direction the bay road stop entrance points towards.
bool IsAnyRoadStopTile(Tile t)
Is tile t a road stop station?
@ FACIL_AIRPORT
Station with an airport.
Definition of base types and functions in a cross-platform compatible way.
#define MAX_UVALUE(type)
The largest value that can be entered in a variable.
Definition stdafx.h:343
#define lengthof(array)
Return the length of an fixed size array.
Definition stdafx.h:280
size_t Utf8StringLength(const char *s)
Get the length of an UTF-8 encoded string in number of characters and thus not the number of bytes th...
Definition string.cpp:359
Functions related to low-level strings.
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
Definition strings.cpp:104
std::string GetString(StringID string)
Resolve the given StringID into a std::string with all the associated DParam lookups and formatting.
Definition strings.cpp:333
void SetDParamStr(size_t n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition strings.cpp:371
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)
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
Class to backup a specific variable and restore it later.
void Restore()
Restore the variable.
Owner owner
The owner of this station.
Class for storing amounts of cargo.
Definition cargo_type.h:114
static void InvalidateAllFrom(SourceType src_type, SourceID src)
Invalidates (sets source_id to INVALID_SOURCE) all cargo packets from given source.
Specification of a cargo type.
Definition cargotype.h:76
static IterateWrapper Iterate(size_t from=0)
Returns an iterable ensemble of all valid CargoSpec.
Definition cargotype.h:195
static std::array< std::vector< const CargoSpec * >, NUM_TPE > town_production_cargoes
List of cargo specs for each Town Product Effect.
Definition cargotype.h:27
bool value
tells if the bool cheat is active or not
Definition cheat_type.h:18
Cheat magic_bulldozer
dynamite industries, objects
Definition cheat_type.h:27
GUISettings gui
settings related to the GUI
bool build_on_slopes
allow building on slopes
uint8_t number_towns
the amount of towns
uint8_t town_council_tolerance
minimum required town ratings to be allowed to demolish stuff
This structure is the same for both Industries and Houses.
Definition sprite.h:67
bool bribe
enable bribing the local authority
TownFounding found_town
town founding.
bool exclusive_rights
allow buying exclusive rights
uint8_t initial_city_size
multiplier for the initial size of the cities compared to towns
TownLayout town_layout
select town layout,
bool allow_town_level_crossings
towns are allowed to build level crossings
uint8_t town_growth_rate
town growth rate
bool allow_town_roads
towns are allowed to build roads (always allowed when generating world / in SE)
bool fund_buildings
allow funding new buildings
bool fund_roads
allow funding local road reconstruction
TownCargoGenMode town_cargogen_mode
algorithm for generating cargo from houses,
uint8_t dist_local_authority
distance for town local authority, default 20
uint8_t larger_towns
the number of cities to build. These start off larger and grow twice as fast
Information about GRF, used in the game and (part of it) in savegames.
const char * GetName() const
Get the name of this grf.
bool HasGrfFile() const
Test if this entity was introduced by NewGRF.
uint32_t grfid
grfid that introduced this entity.
const struct GRFFile * grffile
grf file that introduced this entity
std::array< const struct SpriteGroup *, Tcnt > spritegroup
pointers to the different sprites of the entity
uint16_t override
id of the entity been replaced by
bool population_in_label
show the population of a town in its label?
uint16_t custom_town_number
manually entered number of towns
uint8_t landscape
the landscape we're currently in
uint8_t town_name
the town name generator used for town names
EconomySettings economy
settings to change the economy
ConstructionSettings construction
construction of things in-game
DifficultySettings difficulty
settings related to the difficulty
GameCreationSettings game_creation
settings used during the creation of a game (map)
Stores station stats for a single cargo.
uint8_t probability
Relative probability of appearing (16 is the standard value)
Definition house.h:112
CargoID accepts_cargo[HOUSE_NUM_ACCEPTS]
input cargo slots
Definition house.h:103
uint8_t removal_cost
cost multiplier for removing it
Definition house.h:98
uint8_t mail_generation
mail generation multiplier (tile based, as the acceptances below)
Definition house.h:101
bool enabled
the house is available to build (true by default, but can be disabled by newgrf)
Definition house.h:106
Money GetRemovalCost() const
Get the cost for removing this house.
Definition town_cmd.cpp:225
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:104
TimerGameCalendar::Year max_year
last year it can be built
Definition house.h:96
uint16_t remove_rating_decrease
rating decrease if removed
Definition house.h:100
uint8_t population
population (Zero on other tiles in multi tile house.)
Definition house.h:97
HouseExtraFlags extra_flags
some more flags
Definition house.h:113
uint8_t cargo_acceptance[HOUSE_NUM_ACCEPTS]
acceptance level for the cargo slots
Definition house.h:102
HouseID Index() const
Gets the index of this spec.
HouseClassID class_id
defines the class this house has (not grf file based)
Definition house.h:114
StringID building_name
building name
Definition house.h:99
uint8_t minimum_life
The minimum number of years this house will survive before the town rebuilds it.
Definition house.h:117
GRFFileProps grf_prop
Properties related the the grf file.
Definition house.h:109
uint16_t callback_mask
Bitmask of house callbacks that have to be called.
Definition house.h:110
HouseZones building_availability
where can it be built (climates, zones)
Definition house.h:105
static std::vector< HouseSpec > & Specs()
Get a reference to all HouseSpecs.
Defines the internal data of a functional industry.
Definition industry.h:66
Town * town
Nearest town.
Definition industry.h:95
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition industry.h:238
Size related data of the map.
Definition map_func.h:206
static uint ScaleBySize(uint n)
Scales the given value by the map size, where the given value is for a 256 by 256 map.
Definition map_func.h:328
static IterateWrapper Iterate()
Returns an iterable ensemble of all Tiles.
Definition map_func.h:363
static debug_inline uint Size()
Get the size of the map.
Definition map_func.h:288
An object, such as transmitter, on the map.
Definition object_base.h:23
ObjectType type
Type of the object.
Definition object_base.h:24
Town * town
Town the object is built in.
Definition object_base.h:25
static Object * GetByTile(TileIndex tile)
Get the object associated with a tile.
Represents the covered area of e.g.
void Add(TileIndex to_add)
Add a single tile to a tile area; enlarge if needed.
Definition tilearea.cpp:43
SpriteID sprite
The 'real' sprite.
Definition gfx_type.h:24
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition gfx_type.h:25
Coordinates of a point in 2D.
static size_t GetPoolSize()
Returns first unused index.
Tindex index
Index of this pool item.
static size_t GetNumItems()
Returns number of valid items in the pool.
static bool CleaningPool()
Returns current state of pool cleaning - yes or no.
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
static Titem * Get(size_t index)
Returns Titem with given index.
Base class for all pools.
Definition pool_type.hpp:80
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
Definition pool_type.hpp:84
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
Used as the user_data for FindFurthestFromWater.
uint max_dist
holds the distance that tile is from the water
TownLayout layout
tells us what kind of town we're building
TileIndex tile
holds the tile that was found
Station data structure.
bool CatchmentCoversTown(TownID t) const
Test if the given town ID is covered by our catchment area.
Definition station.cpp:448
Structure for storing data while searching the best place to build a statue.
int tile_count
Number of tiles tried.
TileIndex best_position
Best position found so far.
Tile description for the 'land area information' tool.
Definition tile_cmd.h:52
StringID str
Description of the tile.
Definition tile_cmd.h:53
uint64_t dparam
Parameter of the str string.
Definition tile_cmd.h:54
const char * grf
newGRF used for the tile contents
Definition tile_cmd.h:63
Owner owner[4]
Name of the owner(s)
Definition tile_cmd.h:55
A pair-construct of a TileIndexDiff.
Definition map_type.h:31
int16_t x
The x value of the coordinate.
Definition map_type.h:32
int16_t y
The y value of the coordinate.
Definition map_type.h:33
Tile information, used while rendering the tile.
Definition tile_cmd.h:43
int z
Height.
Definition tile_cmd.h:48
int x
X position of the tile in unit coordinates.
Definition tile_cmd.h:44
Slope tileh
Slope of the tile.
Definition tile_cmd.h:46
TileIndex tile
Tile index.
Definition tile_cmd.h:47
int y
Y position of the tile in unit coordinates.
Definition tile_cmd.h:45
Set of callback functions for performing tile operations of a given tile type.
Definition tile_cmd.h:158
uint32_t population
Current population of people.
Definition town.h:44
uint32_t num_houses
Amount of houses.
Definition town.h:43
std::array< uint32_t, HZB_END > squared_town_zone_radius
UpdateTownRadius updates this given the house count.
Definition town.h:47
TrackedViewportSign sign
Location of name sign, UpdateVirtCoord updates this.
Definition town.h:45
BuildingCounts< uint16_t > building_counts
The number of each type of building in the town.
Definition town.h:48
Struct holding parameters used to generate town name.
uint16_t type
town name style
uint32_t grfid
newgrf ID (0 if not used)
Town data structure.
Definition town.h:54
bool larger_town
if this is a larger town and should grow more quickly
Definition town.h:101
TransportedCargoStat< uint32_t > supplied[NUM_CARGO]
Cargo statistics about supplied cargo.
Definition town.h:79
CompanyMask statues
which companies have a statue?
Definition town.h:70
uint16_t time_until_rebuild
time until we rebuild a house
Definition town.h:93
std::string cached_name
NOSAVE: Cache of the resolved name of the town, if not using a custom town name.
Definition town.h:64
TileIndex xy
town center tile
Definition town.h:55
uint8_t fund_buildings_months
fund buildings program in action?
Definition town.h:98
int16_t ratings[MAX_COMPANIES]
ratings of each company for this town
Definition town.h:77
TownLayout layout
town specific road layout
Definition town.h:102
TransportedCargoStat< uint16_t > received[NUM_TAE]
Cargo statistics about received cargotypes.
Definition town.h:80
static Town * GetRandom()
Return a random valid town.
Definition town_cmd.cpp:196
std::string name
Custom town name. If empty, the town was not renamed and uses the generated name.
Definition town.h:63
uint16_t grow_counter
counter to count when to grow, value is smaller than or equal to growth_rate
Definition town.h:95
uint8_t flags
See TownFlags.
Definition town.h:66
TownCache cache
Container for all cacheable data.
Definition town.h:57
CompanyID exclusivity
which company has exclusivity
Definition town.h:75
void InitializeLayout(TownLayout layout)
Assign the town layout.
Definition town_cmd.cpp:182
bool show_zone
NOSAVE: mark town to show the local authority zone in the viewports.
Definition town.h:104
uint32_t goal[NUM_TAE]
Amount of cargo required for the town to grow.
Definition town.h:81
uint8_t exclusive_counter
months till the exclusivity expires
Definition town.h:76
void UpdateVirtCoord()
Resize the sign (label) of the town after it changes population.
Definition town_cmd.cpp:409
std::string text
General text with additional information.
Definition town.h:83
CompanyMask have_ratings
which companies have a rating
Definition town.h:73
~Town()
Destroy the town.
Definition town_cmd.cpp:110
uint8_t unwanted[MAX_COMPANIES]
how many months companies aren't wanted by towns (bribe)
Definition town.h:74
uint16_t growth_rate
town growth rate
Definition town.h:96
StationList stations_near
NOSAVE: List of nearby stations.
Definition town.h:91
static void PostDestructor(size_t index)
Invalidating of the "nearest town cache" has to be done after removing item from the pool.
Definition town_cmd.cpp:167
uint8_t road_build_months
fund road reconstruction in action?
Definition town.h:99
void UpdatePosition(int center, int top, StringID str, StringID str_small=STR_NULL)
Update the position of the viewport sign.
bool kdtree_valid
Are the sign data valid for use with the _viewport_sign_kdtree?
Tstorage new_max
Maximum amount this month.
Definition town_type.h:115
Tstorage old_max
Maximum amount last month.
Definition town_type.h:114
Tstorage old_act
Actually transported last month.
Definition town_type.h:116
Tstorage new_act
Actually transported this month.
Definition town_type.h:117
Representation of a waypoint.
void DeleteSubsidyWith(SourceType type, SourceID index)
Delete the subsidies associated with a given cargo source type and id.
Definition subsidy.cpp:151
Functions related to subsidies.
Command definitions related to terraforming.
bool IsTileFlat(TileIndex tile, int *h)
Check if a given tile is flat.
Definition tile_map.cpp:95
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
Definition tile_map.cpp:136
int GetTileZ(TileIndex tile)
Get bottom height of the tile.
Definition tile_map.cpp:116
uint TileHash(uint x, uint y)
Calculate a hash value from a tile position.
Definition tile_map.h:324
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition tile_map.h:214
int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
Definition tile_map.h:312
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition tile_map.h:96
bool IsValidTile(Tile tile)
Checks if a tile is valid.
Definition tile_map.h:161
uint TileHash2Bit(uint x, uint y)
Get the last two bits of the TileHash from a tile position.
Definition tile_map.h:342
TropicZone GetTropicZone(Tile tile)
Get the tropic zone.
Definition tile_map.h:238
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
Definition tile_map.h:279
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
static const uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:95
@ MP_TREES
Tile got trees.
Definition tile_type.h:52
@ MP_ROAD
A tile with road (or tram tracks)
Definition tile_type.h:50
@ MP_STATION
A tile of a station.
Definition tile_type.h:53
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
Definition tile_type.h:57
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
Definition tile_type.h:48
@ MP_HOUSE
A house by a town.
Definition tile_type.h:51
@ MP_WATER
Water tile.
Definition tile_type.h:54
@ MP_RAILWAY
A railway.
Definition tile_type.h:49
@ MP_INDUSTRY
Part of an industry.
Definition tile_type.h:56
@ MP_VOID
Invisible tiles at the SW and SE border.
Definition tile_type.h:55
@ MP_OBJECT
Contains objects such as transmitters and owned land.
Definition tile_type.h:58
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
Definition of Interval and OneShot timers.
Definition of the game-calendar-timer.
Definition of the game-economy-timer.
Definition of the tick-based game-timer.
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:33
static const uint TOWN_GROWTH_DESERT
The town needs the cargo for growth when on desert (any amount)
Definition town.h:34
@ TOWN_HAS_CHURCH
There can be only one church by town.
Definition town.h:197
@ TOWN_HAS_STADIUM
There can be only one stadium by town.
Definition town.h:198
@ TOWN_IS_GROWING
Conditions for town growth are met. Grow according to Town::growth_rate.
Definition town.h:196
@ TOWN_CUSTOM_GROWTH
Growth rate is controlled by GS.
Definition town.h:199
TownRatingCheckType
Action types that a company must ask permission for to a town authority.
Definition town.h:175
@ TOWN_RATING_CHECK_TYPE_COUNT
Number of town checking action types.
Definition town.h:178
TownActions
Town actions of a company.
Definition town.h:212
@ TACT_BUILD_STATUE
Build a statue.
Definition town.h:219
@ TACT_ROAD_REBUILD
Rebuild the roads.
Definition town.h:218
@ TACT_BUY_RIGHTS
Buy exclusive transport rights.
Definition town.h:221
@ TACT_BRIBE
Try to bribe the council.
Definition town.h:222
@ TACT_COUNT
Number of available town actions.
Definition town.h:224
@ TACT_FUND_BUILDINGS
Fund new buildings.
Definition town.h:220
@ TACT_NONE
Empty action set.
Definition town.h:213
static const uint CUSTOM_TOWN_NUMBER_DIFFICULTY
value for custom town number in difficulty settings
Definition town.h:28
Town * CalcClosestTownFromTile(TileIndex tile, uint threshold=UINT_MAX)
Return the town closest to the given tile within threshold.
static const uint16_t TOWN_GROWTH_RATE_NONE
Special value for Town::growth_rate to disable town growth.
Definition town.h:35
static bool RoadTypesAllowHouseHere(TileIndex t)
Checks whether at least one surrounding road allows to build a house here.
std::tuple< CommandCost, Money, TownID > CmdFoundTown(DoCommandFlag flags, TileIndex tile, TownSize size, bool city, TownLayout layout, bool random_location, uint32_t townnameparts, const std::string &text)
Create a new town.
static bool CheckFree2x2Area(TileIndex tile, int z, bool noslope)
Checks if a house of size 2x2 can be built at this tile.
static bool TownLayoutAllows2x2HouseHere(Town *t, TileIndex tile)
Checks if the current town layout allows a 2x2 building here.
static void ClearMakeHouseTile(TileIndex tile, Town *t, uint8_t counter, uint8_t stage, HouseID type, uint8_t random_bits)
Clears tile and builds a house or house part.
HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile)
Returns the bit corresponding to the town zone of the specified tile.
static bool GrowTownWithExtraHouse(Town *t, TileIndex tile)
Grows the town with an extra house.
static bool SearchTileForStatue(TileIndex tile, void *user_data)
Search callback function for TownActionBuildStatue.
static bool FindNearestEmptyLand(TileIndex tile, void *)
CircularTileSearch callback to find the nearest land tile.
static bool IsTileAlignedToGrid(TileIndex tile, TownLayout layout)
Towns must all be placed on the same grid or when they eventually interpenetrate their road networks ...
static void AddAcceptedCargoSetMask(CargoID cargo, uint amount, CargoArray &acceptance, CargoTypes &always_accepted)
Fill cargo acceptance array and always_accepted mask, if cargo ID is valid.
Definition town_cmd.cpp:784
static CommandCost TownActionBribe(Town *t, DoCommandFlag flags)
Perform the "bribe" town action.
CommandCost CmdRenameTown(DoCommandFlag flags, TownID town_id, const std::string &text)
Rename a town (server-only).
TileIndexDiff GetHouseNorthPart(HouseID &house)
Determines if a given HouseID is part of a multitile house.
static CommandCost TownActionAdvertiseLarge(Town *t, DoCommandFlag flags)
Perform the "large advertising campaign" town action.
static CommandCost TownActionAdvertiseSmall(Town *t, DoCommandFlag flags)
Perform the "small advertising campaign" town action.
static int GetRating(const Town *t)
Get the rating of a town for the _current_company.
void ClearTownHouse(Town *t, TileIndex tile)
Clear a town house.
static uint GetNormalGrowthRate(Town *t)
Calculates town growth rate in normal conditions (custom growth rate not set).
TownActions GetMaskOfTownActions(CompanyID cid, const Town *t)
Get a list of available town authority actions.
static CommandCost ClearTile_Town(TileIndex tile, DoCommandFlag flags)
Callback function to clear a house tile.
Definition town_cmd.cpp:717
static bool GrowTownWithBridge(const Town *t, const TileIndex tile, const DiagDirection bridge_dir)
Grows the town with a bridge.
const CargoSpec * FindFirstCargoWithTownAcceptanceEffect(TownAcceptanceEffect effect)
Determines the first cargo with a certain town effect.
static TileIndex FindNearestGoodCoastalTownSpot(TileIndex tile, TownLayout layout)
Given a spot on the map (presumed to be a water tile), find a good coastal spot to build a city.
CommandCost CmdTownGrowthRate(DoCommandFlag flags, TownID town_id, uint16_t growth_rate)
Change the growth rate of the town.
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
static bool IsRoadAllowedHere(Town *t, TileIndex tile, DiagDirection dir)
Check if a Road is allowed on a given tile.
static bool CanRoadContinueIntoNextTile(const Town *t, const TileIndex tile, const DiagDirection road_dir)
Checks if a town road can be continued into the next tile.
CommandCost CmdTownRating(DoCommandFlag flags, TownID town_id, CompanyID company_id, int16_t rating)
Change the rating of a company in a town.
static void UpdateTownGrowCounter(Town *t, uint16_t prev_growth_rate)
Updates town grow counter after growth rate change.
CommandCost CmdTownCargoGoal(DoCommandFlag flags, TownID town_id, TownAcceptanceEffect tae, uint32_t goal)
Change the cargo goal of a town.
static int CountActiveStations(Town *t)
Calculates amount of active stations in the range of town (HZB_TOWN_EDGE).
static CommandCost TownCanBePlacedHere(TileIndex tile)
Check if it's possible to place a town on a given tile.
static bool _generating_town
Set if a town is being generated.
Definition town_cmd.cpp:83
static bool CanFollowRoad(TileIndex tile, DiagDirection dir)
Checks whether a road can be followed or is a dead end, that can not be extended to the next tile.
static bool RedundantBridgeExistsNearby(TileIndex tile, void *user_data)
CircularTileSearch proc which checks for a nearby parallel bridge to avoid building redundant bridges...
static bool TownLayoutAllowsHouseHere(Town *t, TileIndex tile)
Checks if the current town layout allows building here.
static void TileLoop_Town(TileIndex tile)
Tile callback function.
Definition town_cmd.cpp:605
static bool CanBuildHouseHere(TileIndex tile, bool noslope)
Check if a house can be built here, based on slope, whether there's a bridge above,...
static CommandCost TownActionAdvertiseMedium(Town *t, DoCommandFlag flags)
Perform the "medium advertising campaign" town action.
static bool GrowTownWithRoad(const Town *t, TileIndex tile, RoadBits rcmd)
Grows the town with a road piece.
CommandCost CmdDeleteTown(DoCommandFlag flags, TownID town_id)
Delete a town (scenario editor or worldgen only).
static void UpdateTownRating(Town *t)
Monthly callback to update town and station ratings.
static void AdvanceHouseConstruction(TileIndex tile)
Increase the construction stage of a house.
Definition town_cmd.cpp:521
static bool TownCanGrowRoad(TileIndex tile)
Test if town can grow road onto a specific tile.
uint32_t GetWorldPopulation()
Get the total population, the sum of all towns in the world.
Definition town_cmd.cpp:462
static bool GrowTownWithTunnel(const Town *t, const TileIndex tile, const DiagDirection tunnel_dir)
Grows the town with a tunnel.
static std::map< const Town *, int > _town_test_ratings
Map of towns to modified ratings, while in town rating test-mode.
static bool CheckClearTile(TileIndex tile)
Check whether the land can be cleared.
const uint8_t _town_action_costs[TACT_COUNT]
Factor in the cost of each town action.
static CommandCost TownActionRoadRebuild(Town *t, DoCommandFlag flags)
Perform the "local road reconstruction" town action.
static CommandCost TownActionFundBuildings(Town *t, DoCommandFlag flags)
Perform the "fund new buildings" town action.
static void TownGenerateCargoOriginal(Town *t, TownProductionEffect tpe, uint8_t rate, StationFinder &stations)
Generate cargo for a house using the original algorithm.
Definition town_cmd.cpp:562
void UpdateTownMaxPass(Town *t)
Update the maximum amount of montly passengers and mail for a town, based on its population.
static void ChangePopulation(Town *t, int mod)
Change the town's population as recorded in the town cache, town label, and town directory.
Definition town_cmd.cpp:447
static bool CheckTownBuild2x2House(TileIndex *tile, Town *t, int maxz, bool noslope)
Checks if a 1x2 or 2x1 building is allowed here, accounting for road layout and tile heights.
CargoArray GetAcceptedCargoOfHouse(const HouseSpec *hs)
Get accepted cargo of a house prototype.
Definition town_cmd.cpp:853
static bool TownAllowedToBuildRoads()
Check if the town is allowed to build roads.
static bool IsNeighborRoadTile(TileIndex tile, const DiagDirection dir, uint dist_multi)
Check for parallel road inside a given distance.
static bool GrowTown(Town *t)
Grow the town.
static DiagDirection RandomDiagDir()
Return a random direction.
Definition town_cmd.cpp:258
static TileIndex AlignTileToGrid(TileIndex tile, TownLayout layout)
Towns must all be placed on the same grid or when they eventually interpenetrate their road networks ...
static Town * CreateRandomTown(uint attempts, uint32_t townnameparts, TownSize size, bool city, TownLayout layout)
Create a random town somewhere in the world.
static void RemoveNearbyStations(Town *t, TileIndex tile, BuildingFlags flags)
Remove stations from nearby station list if a town is no longer in the catchment area of each.
Definition town_cmd.cpp:476
static bool GrowTownAtRoad(Town *t, TileIndex tile)
Try to grow a town at a given road tile.
Town * CalcClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest to the given tile within threshold.
void ClearAllTownCachedNames()
Clear the cached_name of all towns.
Definition town_cmd.cpp:435
void ChangeTownRating(Town *t, int add, int max, DoCommandFlag flags)
Changes town rating of the current company.
static bool FindFurthestFromWater(TileIndex tile, void *user_data)
CircularTileSearch callback; finds the tile furthest from any water.
static Foundation GetFoundation_Town(TileIndex tile, Slope tileh)
Get the foundation for a house.
Definition town_cmd.cpp:326
static void TownGenerateCargo(Town *t, CargoID ct, uint amount, StationFinder &stations, bool affected_by_recession)
Generate cargo for a house, scaled by the current economy scale.
Definition town_cmd.cpp:538
static TimerGameCalendar::Date GetTownRoadTypeFirstIntroductionDate()
Get the calendar date of the earliest town-buildable road type.
Definition town_cmd.cpp:988
static void AnimateTile_Town(TileIndex tile)
Animate a tile for a town.
Definition town_cmd.cpp:350
CommandCost CmdDoTownAction(DoCommandFlag flags, TownID town_id, uint8_t action)
Do a town action.
const TileTypeProcs _tile_type_town_procs
Tile callback functions for a town.
Definition landscape.cpp:51
RoadType GetTownRoadType()
Get the road type that towns should build at this current moment.
Definition town_cmd.cpp:953
static RoadBits GetTownRoadBits(TileIndex tile)
Return the RoadBits of a tile, ignoring depot and bay road stops.
Definition town_cmd.cpp:942
CommandCost CmdExpandTown(DoCommandFlag flags, TownID town_id, uint32_t grow_amount)
Expand a town (scenario editor only).
static CommandCost TownActionBuyRights(Town *t, DoCommandFlag flags)
Perform the "buy exclusive transport rights" town action.
static void DoCreateTown(Town *t, TileIndex tile, uint32_t townnameparts, TownSize size, bool city, TownLayout layout, bool manual)
Actually create a town.
static bool TryBuildTownHouse(Town *t, TileIndex tile)
Tries to build a house at this tile.
static bool TestTownOwnsBridge(TileIndex tile, const Town *t)
Check if a town 'owns' a bridge.
Definition town_cmd.cpp:94
void OnTick_Town()
Iterate through all towns and call their tick handler.
Definition town_cmd.cpp:928
bool CheckTownRoadTypes()
Check if towns are able to build road.
bool GenerateTowns(TownLayout layout)
Generate a number of towns with a given layout.
CommandCost CheckIfAuthorityAllowsNewStation(TileIndex tile, DoCommandFlag flags)
Checks whether the local authority allows construction of a new station (rail, road,...
CommandCost CheckforTownRating(DoCommandFlag flags, Town *t, TownRatingCheckType type)
Does the town authority allow the (destructive) action of the current company?
static bool CheckTownBuild2House(TileIndex *tile, Town *t, int maxz, bool noslope, DiagDirection second)
Checks if a 1x2 or 2x1 building is allowed here, accounting for road layout and tile heights.
static void UpdateTownGrowthRate(Town *t)
Updates town growth rate.
static RoadBits GetTownRoadGridElement(Town *t, TileIndex tile, DiagDirection dir)
Generate the RoadBits of a grid tile.
static void AdvanceSingleHouseConstruction(TileIndex tile)
Helper function for house construction stage progression.
Definition town_cmd.cpp:498
static void TownTickHandler(Town *t)
Handle the town tick for a single town, by growing the town if desired.
Definition town_cmd.cpp:911
static void MakeTownHouse(TileIndex tile, Town *t, uint8_t counter, uint8_t stage, HouseID type, uint8_t random_bits)
Write house information into the map.
void SetTownRatingTestMode(bool mode)
Switch the town rating to test-mode, to allow commands to be tested without affecting current ratings...
static CommandCost TownActionBuildStatue(Town *t, DoCommandFlag flags)
Perform a 9x9 tiles circular search from the center of the town in order to find a free tile to place...
static bool _town_rating_test
If true, town rating is in test-mode.
void UpdateTownRadius(Town *t)
Update the cached town zone radii of a town, based on the number of houses.
static void BuildTownHouse(Town *t, TileIndex tile, const HouseSpec *hs, HouseID house, uint8_t random_bits)
Build a house at this tile.
void AddAcceptedCargoOfHouse(TileIndex tile, HouseID house, const HouseSpec *hs, Town *t, CargoArray &acceptance, CargoTypes &always_accepted)
Determine accepted cargo for a house.
Definition town_cmd.cpp:800
CommandCost CmdTownSetText(DoCommandFlag flags, TownID town_id, const std::string &text)
Set a custom text in the Town window.
static bool IsCloseToTown(TileIndex tile, uint dist)
Determines if a town is close to a tile.
Definition town_cmd.cpp:401
static void UpdateTownGrowth(Town *t)
Updates town growth state (whether it is growing or not).
static void DoClearTownHouseHelper(TileIndex tile, Town *t, HouseID house)
Update data structures when a house is removed.
static RoadBits GenRandomRoadBits()
Generate a random road block.
static bool CheckBuildHouseSameZ(TileIndex tile, int z, bool noslope)
Check if a tile where we want to build a multi-tile house has an appropriate max Z.
static void TownGenerateCargoBinominal(Town *t, TownProductionEffect tpe, uint8_t rate, StationFinder &stations)
Generate cargo for a house using the binominal algorithm.
Definition town_cmd.cpp:582
static bool IsUniqueTownName(const std::string &name)
Verifies this custom name is unique.
static void DrawTile_Town(TileInfo *ti)
Draw a house and its tile.
Definition town_cmd.cpp:267
void UpdateAllTownVirtCoords()
Update the virtual coords needed to draw the town sign for all towns.
Definition town_cmd.cpp:427
static void GrowTownInTile(TileIndex *tile_ptr, RoadBits cur_rb, DiagDirection target_dir, Town *t1)
Grows the given town.
Command definitions related to towns.
Declarations for accessing the k-d tree of towns.
Sprites to use and how to display them for town tiles.
static const DrawBuildingsTileStruct _town_draw_tile_data[]
structure of houses graphics
Definition town_land.h:27
void IncrementHouseAge(Tile t)
Increments the age of the house.
Definition town_map.h:237
void HaltLift(Tile t)
Stop the lift of this animated house from moving.
Definition town_map.h:115
HouseID GetHouseType(Tile t)
Get the type of this house, which is an index into the house spec array.
Definition town_map.h:60
void ResetHouseAge(Tile t)
Sets the age of the house to zero.
Definition town_map.h:226
void IncHouseConstructionTick(Tile t)
Sets the increment stage of a house It is working with the whole counter + stage 5 bits,...
Definition town_map.h:208
uint8_t GetLiftPosition(Tile t)
Get the position of the lift on this animated house.
Definition town_map.h:125
void SetLiftDestination(Tile t, uint8_t dest)
Set the new destination of the lift for this animated house, and activate the LiftHasDestination bit.
Definition town_map.h:93
TimerGameCalendar::Year GetHouseAge(Tile t)
Get the age of the house.
Definition town_map.h:249
void SetLiftPosition(Tile t, uint8_t pos)
Set the position of the lift on this animated house.
Definition town_map.h:135
uint8_t GetLiftDestination(Tile t)
Get the current destination for this lift.
Definition town_map.h:104
uint8_t GetHouseBuildingStage(Tile t)
House Construction Scheme.
Definition town_map.h:183
TownID GetTownIndex(Tile t)
Get the index of which town this house/street is attached to.
Definition town_map.h:23
void SetTownIndex(Tile t, TownID index)
Set the town index for a road or house tile.
Definition town_map.h:35
bool LiftHasDestination(Tile t)
Check if the lift of this animated house has a destination.
Definition town_map.h:82
bool IsHouseCompleted(Tile t)
Get the completion of this house.
Definition town_map.h:145
void MakeHouseTile(Tile t, TownID tid, uint8_t counter, uint8_t stage, HouseID type, uint8_t random_bits)
Make the tile a house.
Definition town_map.h:352
uint8_t GetHouseConstructionTick(Tile t)
Gets the construction stage of a house.
Definition town_map.h:195
static constexpr int RATING_GROWTH_UP_STEP
when a town grows, all companies have rating increased a bit ...
Definition town_type.h:51
static constexpr int RATING_INITIAL
initial rating
Definition town_type.h:43
static constexpr int RATING_ROAD_NEEDED_HOSTILE
"Hostile"
Definition town_type.h:69
@ TCGM_BITCOUNT
Bit-counted algorithm (normal distribution from individual house population)
Definition town_type.h:105
@ TCGM_ORIGINAL
Original algorithm (quadratic cargo by population)
Definition town_type.h:104
static constexpr int RATING_ROAD_NEEDED_NEUTRAL
"Neutral"
Definition town_type.h:68
TownLayout
Town Layouts.
Definition town_type.h:79
@ TL_3X3_GRID
Geometric 3x3 grid algorithm.
Definition town_type.h:84
@ TL_ORIGINAL
Original algorithm (min. 1 distance between roads)
Definition town_type.h:81
@ TL_2X2_GRID
Geometric 2x2 grid algorithm.
Definition town_type.h:83
@ TL_RANDOM
Random town layout.
Definition town_type.h:86
@ TL_BETTER_ROADS
Extended original algorithm (min. 2 distance between roads)
Definition town_type.h:82
@ NUM_TLS
Number of town layouts.
Definition town_type.h:88
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_LENIENT
rating needed, "Lenient" difficulty settings
Definition town_type.h:59
@ TF_CUSTOM_LAYOUT
Allowed, with custom town layout.
Definition town_type.h:97
@ TF_FORBIDDEN
Forbidden.
Definition town_type.h:95
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_HOSTILE
"Hostile"
Definition town_type.h:61
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_PERMISSIVE
"Permissive" (local authority disabled)
Definition town_type.h:62
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_NEUTRAL
"Neutral"
Definition town_type.h:60
static constexpr int RATING_ROAD_NEEDED_LENIENT
rating needed, "Lenient" difficulty settings
Definition town_type.h:67
TownSize
Supported initial town sizes.
Definition town_type.h:19
@ TSZ_RANDOM
Random size, bigger than small, smaller than large.
Definition town_type.h:23
@ TSZ_END
Number of available town sizes.
Definition town_type.h:25
@ TSZ_LARGE
Large town.
Definition town_type.h:22
static const uint MAX_LENGTH_TOWN_NAME_CHARS
The maximum length of a town name in characters including '\0'.
Definition town_type.h:109
static constexpr int RATING_ROAD_NEEDED_PERMISSIVE
"Permissive" (local authority disabled)
Definition town_type.h:70
static constexpr int RATING_GROWTH_MAXIMUM
... up to RATING_MEDIOCRE
Definition town_type.h:52
bool VerifyTownName(uint32_t r, const TownNameParams *par, TownNames *town_names)
Verifies the town name is valid and unique.
Definition townname.cpp:103
bool GenerateTownName(Randomizer &randomizer, uint32_t *townnameparts, TownNames *town_names)
Generates valid town name.
Definition townname.cpp:136
Town name generator stuff.
@ TO_HOUSES
town buildings
bool IsTransparencySet(TransparencyOption to)
Check if the transparency option bit is set and if we aren't in the game menu (there's never transpar...
bool IsInvisibilitySet(TransparencyOption to)
Check if the invisibility option bit is set and if we aren't in the game menu (there's never transpar...
TransportType
Available types of transport.
@ TRANSPORT_ROAD
Transport by road vehicle.
Command definitions related to tunnels and bridges.
Functions that have tunnels and bridges in common.
DiagDirection GetTunnelBridgeDirection(Tile t)
Get the direction pointing to the other end.
TransportType GetTunnelBridgeTransportType(Tile t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
TileIndex GetOtherTunnelBridgeEnd(Tile t)
Determines type of the wormhole and returns its other end.
void AddSortableSpriteToDraw(SpriteID image, PaletteID pal, int x, int y, int w, int h, int dz, int z, bool transparent, int bb_offset_x, int bb_offset_y, int bb_offset_z, const SubSprite *sub)
Draw a (transparent) sprite at given coordinates with a given bounding box.
Definition viewport.cpp:671
void AddChildSpriteScreen(SpriteID image, PaletteID pal, int x, int y, bool transparent, const SubSprite *sub, bool scale, bool relative)
Add a child sprite to a parent sprite.
Definition viewport.cpp:827
void DrawGroundSprite(SpriteID image, PaletteID pal, const SubSprite *sub, int extra_offs_x, int extra_offs_y)
Draws a ground sprite for the current tile.
Definition viewport.cpp:587
Functions related to (drawing on) viewports.
bool HasTileWaterGround(Tile t)
Checks whether the tile has water at the ground.
Definition water_map.h:350
bool IsWaterTile(Tile t)
Is it a water tile with plain water?
Definition water_map.h:190
bool IsSea(Tile t)
Is it a sea water tile?
Definition water_map.h:158
Base of waypoints.
void CloseWindowById(WindowClass cls, WindowNumber number, bool force, int data)
Close a window by its class and window number (if it is open).
Definition window.cpp:1140
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition window.cpp:3127
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition window.cpp:3219
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition window.cpp:3101
Window functions not directly related to making/drawing windows.
@ WC_TOWN_AUTHORITY
Town authority; Window numbers:
@ WC_STATION_VIEW
Station view; Window numbers:
@ WC_TOWN_VIEW
Town view; Window numbers:
@ WC_TOWN_DIRECTORY
Town directory; Window numbers: