OpenTTD Source: src/town_cmd.cpp Source File

OpenTTD Source 15.0-beta1

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"
57#include "timer/timer_game_calendar.h"
58#include "timer/timer_game_economy.h"
59#include "timer/timer_game_tick.h"
60
61#include "table/strings.h"
62#include "table/town_land.h"
63
64#include "safeguards.h"
65
66/* Initialize the town-pool */
67 TownPool _town_pool("Town");
68 INSTANTIATE_POOL_METHODS(Town)
69
70
71 TownKdtree _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
83 static bool _generating_town = false;
84
94 static bool TestTownOwnsBridge(TileIndex tile, const Town *t)
95{
96 if (!IsTileOwner(tile, OWNER_TOWN)) return false;
97
98 TileIndex adjacent = tile + TileOffsByDiagDir(ReverseDiagDir(GetTunnelBridgeDirection(tile)));
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 */
103 adjacent = tile + TileOffsByDiagDir(ReverseDiagDir(GetTunnelBridgeDirection(GetOtherTunnelBridgeEnd(tile))));
104 town_owned = IsTileType(adjacent, MP_ROAD) && IsTileOwner(adjacent, OWNER_TOWN) && GetTownIndex(adjacent) == t->index;
105 }
106
107 return town_owned;
108}
109
110Town::~Town()
111{
112 if (CleaningPool()) return;
113
114 /* Delete town authority window
115 * and remove from list of sorted towns */
116 CloseWindowById(WC_TOWN_VIEW, this->index);
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
156 DeleteSubsidyWith(SourceType::Town, this->index);
157 DeleteNewGRFInspectWindow(GSF_FAKE_TOWNS, this->index);
158 CargoPacket::InvalidateAllFrom(SourceType::Town, this->index);
159 MarkWholeScreenDirty();
160}
161
162
167 void Town::PostDestructor(size_t)
168{
169 InvalidateWindowData(WC_TOWN_DIRECTORY, 0, TDIWD_FORCE_REBUILD);
170 UpdateNearestTownForRoadTiles(false);
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
182 void Town::InitializeLayout(TownLayout layout)
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
225 Money HouseSpec::GetRemovalCost() const
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
258 static inline DiagDirection RandomDiagDir()
259{
260 return (DiagDirection)(RandomRange(DIAGDIR_END));
261}
262
267 static 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
286 if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
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,
303 IsTransparencySet(TO_HOUSES)
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
326 static Foundation GetFoundation_Town(TileIndex tile, Slope tileh)
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
350 static void AnimateTile_Town(TileIndex tile)
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
392 MarkTileDirtyByTile(tile);
393}
394
401 static 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
409 void Town::UpdateVirtCoord()
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
423 SetWindowDirty(WC_TOWN_VIEW, this->index);
424}
425
427 void UpdateAllTownVirtCoords()
428{
429 for (Town *t : Town::Iterate()) {
430 t->UpdateVirtCoord();
431 }
432}
433
435 void ClearAllTownCachedNames()
436{
437 for (Town *t : Town::Iterate()) {
438 t->cached_name.clear();
439 }
440}
441
447 static 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
453 if (_settings_client.gui.population_in_label) t->UpdateVirtCoord();
454
455 InvalidateWindowData(WC_TOWN_DIRECTORY, 0, TDIWD_POPULATION_CHANGE);
456}
457
462uint32_t GetWorldPopulation()
463{
464 uint32_t pop = 0;
465 for (const Town *t : Town::Iterate()) pop += t->cache.population;
466 return pop;
467}
468
476 static 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
498 static void AdvanceSingleHouseConstruction(TileIndex tile)
499{
500 assert(IsTileType(tile, MP_HOUSE));
501
502 /* Progress in construction stages */
503 IncHouseConstructionTick(tile);
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 }
514 MarkTileDirtyByTile(tile);
515}
516
521 static void AdvanceHouseConstruction(TileIndex tile)
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
538 static 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
562 static 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
582 static 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
605 static 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. */
615 AdvanceHouseConstruction(tile);
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
634 if (HasBit(hs->callback_mask, CBM_HOUSE_PRODUCE_CARGO)) {
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 {
650 switch (_settings_game.economy.town_cargogen_mode) {
651 case TCGM_ORIGINAL:
652 /* Original (quadratic) cargo generation algorithm */
653 TownGenerateCargoOriginal(t, TPE_PASSENGERS, hs->population, stations);
654 TownGenerateCargoOriginal(t, TPE_MAIL, hs->mail_generation, stations);
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)) {
662 TownGenerateCargoBinominal(t, TPE_PASSENGERS, hs->population, stations);
663 TownGenerateCargoBinominal(t, TPE_MAIL, hs->mail_generation, stations);
664 }
665 break;
666
667 default:
668 NOT_REACHED();
669 }
670 }
671
672 Backup<CompanyID> cur_company(_current_company, OWNER_TOWN);
673
674 if ((hs->building_flags & BUILDING_HAS_1_TILE) &&
675 HasBit(t->flags, TOWN_IS_GROWING) &&
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
717 static CommandCost ClearTile_Town(TileIndex tile, DoCommandFlag flags)
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
724 CommandCost cost(EXPENSES_CONSTRUCTION);
725 cost.AddCost(hs->GetRemovalCost());
726
727 int rating = hs->remove_rating_decrease;
728 Town *t = Town::GetByTile(tile);
729
730 if (Company::IsValidID(_current_company)) {
731 if (rating > t->ratings[_current_company] && !(flags & DC_NO_TEST_TOWN_RATING) &&
732 !_cheats.magic_bulldozer.value && _settings_game.difficulty.town_council_tolerance != TOWN_COUNCIL_PERMISSIVE) {
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
752 if (HasBit(hs->callback_mask, CBM_HOUSE_PRODUCE_CARGO)) {
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
784 static 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
800 void 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 */
810 if (HasBit(hs->callback_mask, CBM_HOUSE_ACCEPT_CARGO)) {
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 */
821 if (HasBit(hs->callback_mask, CBM_HOUSE_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
853 CargoArray GetAcceptedCargoOfHouse(const HouseSpec *hs)
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) {
872 ErrorUnknownCallbackResult(hs->grf_prop.grfid, CBID_HOUSE_CUSTOM_NAME, callback_res);
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
911 static 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
928 void OnTick_Town()
929{
930 if (_game_mode == GM_EDITOR) return;
931
932 for (Town *t : Town::Iterate()) {
933 TownTickHandler(t);
934 }
935}
936
942 static RoadBits GetTownRoadBits(TileIndex tile)
943{
944 if (IsRoadDepotTile(tile) || IsBayRoadStopTile(tile)) return ROAD_NONE;
945
946 return GetAnyRoadBits(tile, RTT_ROAD, true);
947}
948
953 RoadType GetTownRoadType()
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. */
971 if (IsInsideMM(rti->introduction_date, 0, CalendarTime::MAX_DATE.base()) && rti->introduction_date > TimerGameCalendar::date) continue;
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
988 static 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
1009 bool CheckTownRoadTypes()
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
1033 static 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] = {
1039 TileOffsByDiagDir(ChangeDiagDir(dir, DIAGDIRDIFF_90RIGHT)),
1040 TileOffsByDiagDir(ChangeDiagDir(dir, DIAGDIRDIFF_90LEFT)),
1041 TileOffsByDiagDir(ReverseDiagDir(dir)),
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
1067 static bool IsRoadAllowedHere(Town *t, TileIndex tile, DiagDirection dir)
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. */
1079 RoadType rt = GetTownRoadType();
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() &&
1081 Command<CMD_LANDSCAPE_CLEAR>::Do(DC_AUTO | DC_NO_WATER, tile).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. */
1098 res = std::get<0>(Command<CMD_TERRAFORM_LAND>::Do(DC_EXEC | DC_AUTO | DC_NO_WATER,
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;
1117 Command<CMD_TERRAFORM_LAND>::Do(DC_AUTO | DC_NO_WATER | DC_EXEC, tile, edges, dir);
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
1144 static RoadBits GetTownRoadGridElement(Town *t, TileIndex tile, DiagDirection dir)
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 */
1190 return DiagDirToRoadBits(dir) | DiagDirToRoadBits(ReverseDiagDir(dir));
1191}
1192
1203 static bool GrowTownWithExtraHouse(Town *t, TileIndex tile)
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
1245 static bool GrowTownWithRoad(const Town *t, TileIndex tile, RoadBits rcmd)
1246{
1247 RoadType rt = GetTownRoadType();
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
1264 static 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));
1269 RoadType rt = GetTownRoadType();
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
1306 static 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
1331 static 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? */
1391 RoadType rt = GetTownRoadType();
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
1412 static 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. */
1462 RoadType rt = GetTownRoadType();
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
1478 static inline bool RoadTypesAllowHouseHere(TileIndex t)
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
1506 static bool TownCanGrowRoad(TileIndex tile)
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
1519 static inline bool TownAllowedToBuildRoads()
1520{
1521 return _settings_game.economy.allow_town_roads || _generating_world || _game_mode == GM_EDITOR;
1522}
1523
1541 static 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;
1554 if (!_settings_game.economy.allow_town_level_crossings && IsTileType(tile, MP_RAILWAY)) 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 */
1586 if (!IsTileType(TileAddByDiagDir(tile, ChangeDiagDir(target_dir, DIAGDIRDIFF_90RIGHT)), MP_HOUSE) &&
1587 !IsTileType(TileAddByDiagDir(tile, ChangeDiagDir(target_dir, DIAGDIRDIFF_90LEFT)), MP_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
1749 static bool CanFollowRoad(TileIndex tile, DiagDirection dir)
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);
1756 if (TownAllowedToBuildRoads()) {
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. */
1780 RoadBits back_rb = DiagDirToRoadBits(ReverseDiagDir(dir));
1781 return (target_rb & back_rb) != 0 && (target_rb & ~back_rb) != 0;
1782 }
1783}
1784
1791 static 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
1873 static RoadBits GenRandomRoadBits()
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
1887 static 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 */
1906 Backup<CompanyID> cur_company(_current_company, OWNER_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. */
1922 if (TownAllowedToBuildRoads()) {
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()) {
1928 RoadType rt = GetTownRoadType();
1929 Command<CMD_BUILD_ROAD>::Do(DC_EXEC | DC_AUTO, tile, GenRandomRoadBits(), rt, DRD_NONE, t->index);
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
1946 void UpdateTownRadius(Town *t)
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
1993 void UpdateTownMaxPass(Town *t)
1994{
1995 for (const CargoSpec *cs : CargoSpec::town_production_cargoes[TPE_PASSENGERS]) {
1996 t->supplied[cs->Index()].old_max = ScaleByCargoScale(t->cache.population >> 3, true);
1997 }
1998 for (const CargoSpec *cs : CargoSpec::town_production_cargoes[TPE_MAIL]) {
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
2017 static 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;
2024 UpdateTownRadius(t);
2025 t->flags = 0;
2026 t->cache.population = 0;
2027 InitializeBuildingCounts(t);
2028 /* Spread growth across ticks so even if there are many
2029 * similar towns they're unlikely to grow all in one tick */
2030 t->grow_counter = t->index % Ticks::TOWN_GROWTH_TICKS;
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 */
2037 switch (_settings_game.game_creation.landscape) {
2038 case LT_ARCTIC:
2039 if (FindFirstCargoWithTownAcceptanceEffect(TAE_FOOD) != nullptr) t->goal[TAE_FOOD] = TOWN_GROWTH_WINTER;
2040 break;
2041
2042 case LT_TROPIC:
2043 if (FindFirstCargoWithTownAcceptanceEffect(TAE_FOOD) != nullptr) t->goal[TAE_FOOD] = TOWN_GROWTH_DESERT;
2044 if (FindFirstCargoWithTownAcceptanceEffect(TAE_WATER) != nullptr) t->goal[TAE_WATER] = TOWN_GROWTH_DESERT;
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;
2053 t->exclusivity = INVALID_COMPANY;
2054 t->exclusive_counter = 0;
2055 t->statues = 0;
2056
2057 {
2058 TownNameParams tnp(_settings_game.game_creation.town_name);
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;
2074 UpdateTownRadius(t);
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;
2085 UpdateTownRadius(t);
2086 UpdateTownGrowthRate(t);
2087 UpdateTownMaxPass(t);
2088 UpdateAirportsNoise();
2089}
2090
2096 static CommandCost TownCanBePlacedHere(TileIndex tile)
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
2113 return CommandCost(EXPENSES_OTHER);
2114}
2115
2121 static 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{
2144 TownNameParams par(_settings_game.game_creation.town_name);
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 };
2154 if (_settings_game.economy.found_town != TF_CUSTOM_LAYOUT && layout != _settings_game.economy.town_layout) {
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);
2196 UpdateNearestTownForRoadTiles(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
2205 UpdateNearestTownForRoadTiles(false);
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
2221 if (_current_company == OWNER_DEITY) {
2222 SetDParam(0, t->index);
2223 AddTileNewsItem(STR_NEWS_NEW_TOWN_UNSPONSORED, NT_INDUSTRY_OPEN, tile);
2224 } else {
2225 SetDParam(0, _current_company);
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
2249 static TileIndex AlignTileToGrid(TileIndex tile, TownLayout layout)
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
2267 static bool IsTileAlignedToGrid(TileIndex tile, TownLayout layout)
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
2279 struct SpotData {
2280 TileIndex tile;
2281 uint max_dist;
2282 TownLayout layout;
2283};
2284
2301 static 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
2321 static bool FindNearestEmptyLand(TileIndex tile, void *)
2322{
2323 return IsTileType(tile, MP_CLEAR);
2324}
2325
2338 static TileIndex FindNearestGoodCoastalTownSpot(TileIndex tile, TownLayout layout)
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
2361 static 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
2390 Backup<CompanyID> cur_company(_current_company, OWNER_TOWN);
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
2413 bool GenerateTowns(TownLayout layout)
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
2422 SetGeneratingWorldProgress(GWP_TOWN, total);
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);
2438 IncreaseGeneratingWorldProgress(GWP_TOWN);
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
2498 static inline void ClearMakeHouseTile(TileIndex tile, Town *t, uint8_t counter, uint8_t stage, HouseID type, uint8_t random_bits)
2499{
2500 [[maybe_unused]] CommandCost cc = Command<CMD_LANDSCAPE_CLEAR>::Do(DC_EXEC | DC_AUTO | DC_NO_WATER, tile);
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
2521 static 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
2543 static 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
2568 static 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
2587 static 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
2608 static 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
2639 static 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
2676 static 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
2701 static 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
2725 static 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) {
2740 ChangePopulation(t, hs->population);
2741 } else {
2742 construction_counter = GB(construction_random, 2, 2);
2743 }
2744 }
2745
2746 MakeTownHouse(tile, t, construction_counter, construction_stage, house, random_bits);
2747 UpdateTownRadius(t);
2748 UpdateTownGrowthRate(t);
2749}
2750
2757 static 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? */
2773 int land = _settings_game.game_creation.landscape;
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
2864 if (HasBit(hs->callback_mask, CBM_HOUSE_ALLOW_CONSTRUCTION)) {
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
2880 CommandCost 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? */
2899 CommandCost cost = Command<CMD_LANDSCAPE_CLEAR>::Do(DC_AUTO | DC_NO_WATER, tile);
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) {
2915 cost = Command<CMD_LANDSCAPE_CLEAR>::Do(DC_AUTO | DC_NO_WATER, subtile);
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
2934 static void DoClearTownHouseHelper(TileIndex tile, Town *t, HouseID house)
2935{
2936 assert(IsTileType(tile, MP_HOUSE));
2937 DecreaseBuildingCount(t, house);
2938 DoClearSquare(tile);
2939
2940 DeleteNewGRFInspectWindow(GSF_HOUSES, tile.base());
2941}
2942
2950 TileIndexDiff GetHouseNorthPart(HouseID &house)
2951{
2952 if (house >= 3) { // house id 0,1,2 MUST be single tile houses, or this code breaks.
2953 if (HouseSpec::Get(house - 1)->building_flags & TILE_SIZE_2x1) {
2954 house--;
2955 return TileDiffXY(-1, 0);
2956 } else if (HouseSpec::Get(house - 1)->building_flags & BUILDING_2_TILES_Y) {
2957 house--;
2958 return TileDiffXY(0, -1);
2959 } else if (HouseSpec::Get(house - 2)->building_flags & BUILDING_HAS_4_TILES) {
2960 house -= 2;
2961 return TileDiffXY(-1, 0);
2962 } else if (HouseSpec::Get(house - 3)->building_flags & BUILDING_HAS_4_TILES) {
2963 house -= 3;
2964 return TileDiffXY(-1, -1);
2965 }
2966 }
2967 return TileDiffXY(0, 0);
2968}
2969
2975 void ClearTownHouse(Town *t, TileIndex tile)
2976{
2977 assert(IsTileType(tile, MP_HOUSE));
2978
2979 HouseID house = GetHouseType(tile);
2980
2981 /* The northernmost tile of the house is the main house. */
2982 tile += GetHouseNorthPart(house);
2983
2984 const HouseSpec *hs = HouseSpec::Get(house);
2985
2986 /* Remove population from the town if the house is finished. */
2987 if (IsHouseCompleted(tile)) {
2988 ChangePopulation(t, -hs->population);
2989 }
2990
2991 t->cache.num_houses--;
2992
2993 /* Clear flags for houses that only may exist once/town. */
2994 if (hs->building_flags & BUILDING_IS_CHURCH) {
2995 ClrBit(t->flags, TOWN_HAS_CHURCH);
2996 } else if (hs->building_flags & BUILDING_IS_STADIUM) {
2997 ClrBit(t->flags, TOWN_HAS_STADIUM);
2998 }
2999
3000 /* Do the actual clearing of tiles */
3001 DoClearTownHouseHelper(tile, t, house);
3002 if (hs->building_flags & BUILDING_2_TILES_Y) DoClearTownHouseHelper(tile + TileDiffXY(0, 1), t, ++house);
3003 if (hs->building_flags & BUILDING_2_TILES_X) DoClearTownHouseHelper(tile + TileDiffXY(1, 0), t, ++house);
3004 if (hs->building_flags & BUILDING_HAS_4_TILES) DoClearTownHouseHelper(tile + TileDiffXY(1, 1), t, ++house);
3005
3006 RemoveNearbyStations(t, tile, hs->building_flags);
3007
3008 UpdateTownRadius(t);
3009}
3010
3018 CommandCost CmdRenameTown(DoCommandFlag flags, TownID town_id, const std::string &text)
3019{
3020 Town *t = Town::GetIfValid(town_id);
3021 if (t == nullptr) return CMD_ERROR;
3022
3023 bool reset = text.empty();
3024
3025 if (!reset) {
3026 if (Utf8StringLength(text) >= MAX_LENGTH_TOWN_NAME_CHARS) return CMD_ERROR;
3027 if (!IsUniqueTownName(text)) return CommandCost(STR_ERROR_NAME_MUST_BE_UNIQUE);
3028 }
3029
3030 if (flags & DC_EXEC) {
3031 t->cached_name.clear();
3032 if (reset) {
3033 t->name.clear();
3034 } else {
3035 t->name = text;
3036 }
3037
3038 t->UpdateVirtCoord();
3039 InvalidateWindowData(WC_TOWN_DIRECTORY, 0, TDIWD_FORCE_RESORT);
3040 ClearAllStationCachedNames();
3041 ClearAllIndustryCachedNames();
3042 UpdateAllStationVirtCoords();
3043 }
3044 return CommandCost();
3045}
3046
3052 const CargoSpec *FindFirstCargoWithTownAcceptanceEffect(TownAcceptanceEffect effect)
3053{
3054 for (const CargoSpec *cs : CargoSpec::Iterate()) {
3055 if (cs->town_acceptance_effect == effect) return cs;
3056 }
3057 return nullptr;
3058}
3059
3068 CommandCost CmdTownCargoGoal(DoCommandFlag flags, TownID town_id, TownAcceptanceEffect tae, uint32_t goal)
3069{
3070 if (_current_company != OWNER_DEITY) return CMD_ERROR;
3071
3072 if (tae < TAE_BEGIN || tae >= TAE_END) return CMD_ERROR;
3073
3074 Town *t = Town::GetIfValid(town_id);
3075 if (t == nullptr) return CMD_ERROR;
3076
3077 /* Validate if there is a cargo which is the requested TownEffect */
3078 const CargoSpec *cargo = FindFirstCargoWithTownAcceptanceEffect(tae);
3079 if (cargo == nullptr) return CMD_ERROR;
3080
3081 if (flags & DC_EXEC) {
3082 t->goal[tae] = goal;
3083 UpdateTownGrowth(t);
3084 InvalidateWindowData(WC_TOWN_VIEW, town_id);
3085 }
3086
3087 return CommandCost();
3088}
3089
3097 CommandCost CmdTownSetText(DoCommandFlag flags, TownID town_id, const std::string &text)
3098{
3099 if (_current_company != OWNER_DEITY) return CMD_ERROR;
3100 Town *t = Town::GetIfValid(town_id);
3101 if (t == nullptr) return CMD_ERROR;
3102
3103 if (flags & DC_EXEC) {
3104 t->text.clear();
3105 if (!text.empty()) t->text = text;
3106 InvalidateWindowData(WC_TOWN_VIEW, town_id);
3107 }
3108
3109 return CommandCost();
3110}
3111
3119 CommandCost CmdTownGrowthRate(DoCommandFlag flags, TownID town_id, uint16_t growth_rate)
3120{
3121 if (_current_company != OWNER_DEITY) return CMD_ERROR;
3122
3123 Town *t = Town::GetIfValid(town_id);
3124 if (t == nullptr) return CMD_ERROR;
3125
3126 if (flags & DC_EXEC) {
3127 if (growth_rate == 0) {
3128 /* Just clear the flag, UpdateTownGrowth will determine a proper growth rate */
3129 ClrBit(t->flags, TOWN_CUSTOM_GROWTH);
3130 } else {
3131 uint old_rate = t->growth_rate;
3132 if (t->grow_counter >= old_rate) {
3133 /* This also catches old_rate == 0 */
3134 t->grow_counter = growth_rate;
3135 } else {
3136 /* Scale grow_counter, so half finished houses stay half finished */
3137 t->grow_counter = t->grow_counter * growth_rate / old_rate;
3138 }
3139 t->growth_rate = growth_rate;
3140 SetBit(t->flags, TOWN_CUSTOM_GROWTH);
3141 }
3142 UpdateTownGrowth(t);
3143 InvalidateWindowData(WC_TOWN_VIEW, town_id);
3144 }
3145
3146 return CommandCost();
3147}
3148
3157 CommandCost CmdTownRating(DoCommandFlag flags, TownID town_id, CompanyID company_id, int16_t rating)
3158{
3159 if (_current_company != OWNER_DEITY) return CMD_ERROR;
3160
3161 Town *t = Town::GetIfValid(town_id);
3162 if (t == nullptr) return CMD_ERROR;
3163
3164 if (!Company::IsValidID(company_id)) return CMD_ERROR;
3165
3166 int16_t new_rating = Clamp(rating, RATING_MINIMUM, RATING_MAXIMUM);
3167 if (flags & DC_EXEC) {
3168 t->ratings[company_id] = new_rating;
3169 InvalidateWindowData(WC_TOWN_AUTHORITY, town_id);
3170 }
3171
3172 return CommandCost();
3173}
3174
3182 CommandCost CmdExpandTown(DoCommandFlag flags, TownID town_id, uint32_t grow_amount)
3183{
3184 if (_game_mode != GM_EDITOR && _current_company != OWNER_DEITY) return CMD_ERROR;
3185 Town *t = Town::GetIfValid(town_id);
3186 if (t == nullptr) return CMD_ERROR;
3187
3188 if (flags & DC_EXEC) {
3189 /* The more houses, the faster we grow */
3190 if (grow_amount == 0) {
3191 uint amount = RandomRange(ClampTo<uint16_t>(t->cache.num_houses / 10)) + 3;
3192 t->cache.num_houses += amount;
3193 UpdateTownRadius(t);
3194
3195 uint n = amount * 10;
3196 do GrowTown(t); while (--n);
3197
3198 t->cache.num_houses -= amount;
3199 } else {
3200 for (; grow_amount > 0; grow_amount--) {
3201 /* Try several times to grow, as we are really suppose to grow */
3202 for (uint i = 0; i < 25; i++) if (GrowTown(t)) break;
3203 }
3204 }
3205 UpdateTownRadius(t);
3206
3207 UpdateTownMaxPass(t);
3208 }
3209
3210 return CommandCost();
3211}
3212
3219 CommandCost CmdDeleteTown(DoCommandFlag flags, TownID town_id)
3220{
3221 if (_game_mode != GM_EDITOR && !_generating_world) return CMD_ERROR;
3222 Town *t = Town::GetIfValid(town_id);
3223 if (t == nullptr) return CMD_ERROR;
3224
3225 /* Stations refer to towns. */
3226 for (const Station *st : Station::Iterate()) {
3227 if (st->town == t) {
3228 /* Non-oil rig stations are always a problem. */
3229 if (!(st->facilities & FACIL_AIRPORT) || st->airport.type != AT_OILRIG) return CMD_ERROR;
3230 /* We can only automatically delete oil rigs *if* there's no vehicle on them. */
3231 CommandCost ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, st->airport.tile);
3232 if (ret.Failed()) return ret;
3233 }
3234 }
3235
3236 /* Waypoints refer to towns. */
3237 for (const Waypoint *wp : Waypoint::Iterate()) {
3238 if (wp->town == t) return CMD_ERROR;
3239 }
3240
3241 /* Depots refer to towns. */
3242 for (const Depot *d : Depot::Iterate()) {
3243 if (d->town == t) return CMD_ERROR;
3244 }
3245
3246 /* Check all tiles for town ownership. First check for bridge tiles, as
3247 * these do not directly have an owner so we need to check adjacent
3248 * tiles. This won't work correctly in the same loop if the adjacent
3249 * tile was already deleted earlier in the loop. */
3250 for (const auto current_tile : Map::Iterate()) {
3251 if (IsTileType(current_tile, MP_TUNNELBRIDGE) && TestTownOwnsBridge(current_tile, t)) {
3252 CommandCost ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, current_tile);
3253 if (ret.Failed()) return ret;
3254 }
3255 }
3256
3257 /* Check all remaining tiles for town ownership. */
3258 for (const auto current_tile : Map::Iterate()) {
3259 bool try_clear = false;
3260 switch (GetTileType(current_tile)) {
3261 case MP_ROAD:
3262 try_clear = HasTownOwnedRoad(current_tile) && GetTownIndex(current_tile) == t->index;
3263 break;
3264
3265 case MP_HOUSE:
3266 try_clear = GetTownIndex(current_tile) == t->index;
3267 break;
3268
3269 case MP_INDUSTRY:
3270 try_clear = Industry::GetByTile(current_tile)->town == t;
3271 break;
3272
3273 case MP_OBJECT:
3274 if (Town::GetNumItems() == 1) {
3275 /* No towns will be left, remove it! */
3276 try_clear = true;
3277 } else {
3278 Object *o = Object::GetByTile(current_tile);
3279 if (o->town == t) {
3280 if (o->type == OBJECT_STATUE) {
3281 /* Statue... always remove. */
3282 try_clear = true;
3283 } else {
3284 /* Tell to find a new town. */
3285 if (flags & DC_EXEC) o->town = nullptr;
3286 }
3287 }
3288 }
3289 break;
3290
3291 default:
3292 break;
3293 }
3294 if (try_clear) {
3295 CommandCost ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, current_tile);
3296 if (ret.Failed()) return ret;
3297 }
3298 }
3299
3300 /* The town destructor will delete the other things related to the town. */
3301 if (flags & DC_EXEC) {
3302 _town_kdtree.Remove(t->index);
3303 if (t->cache.sign.kdtree_valid) _viewport_sign_kdtree.Remove(ViewportSignKdtreeItem::MakeTown(t->index));
3304 delete t;
3305 }
3306
3307 return CommandCost();
3308}
3309
3314 const uint8_t _town_action_costs[TACT_COUNT] = {
3315 2, 4, 9, 35, 48, 53, 117, 175
3316};
3317
3324 static CommandCost TownActionAdvertiseSmall(Town *t, DoCommandFlag flags)
3325{
3326 if (flags & DC_EXEC) {
3327 ModifyStationRatingAround(t->xy, _current_company, 0x40, 10);
3328 }
3329 return CommandCost();
3330}
3331
3338 static CommandCost TownActionAdvertiseMedium(Town *t, DoCommandFlag flags)
3339{
3340 if (flags & DC_EXEC) {
3341 ModifyStationRatingAround(t->xy, _current_company, 0x70, 15);
3342 }
3343 return CommandCost();
3344}
3345
3352 static CommandCost TownActionAdvertiseLarge(Town *t, DoCommandFlag flags)
3353{
3354 if (flags & DC_EXEC) {
3355 ModifyStationRatingAround(t->xy, _current_company, 0xA0, 20);
3356 }
3357 return CommandCost();
3358}
3359
3366 static CommandCost TownActionRoadRebuild(Town *t, DoCommandFlag flags)
3367{
3368 /* Check if the company is allowed to fund new roads. */
3369 if (!_settings_game.economy.fund_roads) return CMD_ERROR;
3370
3371 if (flags & DC_EXEC) {
3372 t->road_build_months = 6;
3373
3374 SetDParam(0, _current_company);
3375 std::string company_name = GetString(STR_COMPANY_NAME);
3376
3377 SetDParam(0, t->index);
3378 SetDParamStr(1, company_name);
3379
3380 AddNewsItem(
3381 TimerGameEconomy::UsingWallclockUnits() ? STR_NEWS_ROAD_REBUILDING_MINUTES : STR_NEWS_ROAD_REBUILDING_MONTHS,
3382 NT_GENERAL, NF_NORMAL, NR_TOWN, t->index, NR_NONE, UINT32_MAX);
3383 AI::BroadcastNewEvent(new ScriptEventRoadReconstruction((ScriptCompany::CompanyID)(Owner)_current_company, t->index));
3384 Game::NewEvent(new ScriptEventRoadReconstruction((ScriptCompany::CompanyID)(Owner)_current_company, t->index));
3385 }
3386 return CommandCost();
3387}
3388
3394 static bool CheckClearTile(TileIndex tile)
3395{
3396 Backup<CompanyID> cur_company(_current_company, OWNER_NONE);
3397 CommandCost r = Command<CMD_LANDSCAPE_CLEAR>::Do(DC_NONE, tile);
3398 cur_company.Restore();
3399 return r.Succeeded();
3400}
3401
3403 struct StatueBuildSearchData {
3404 TileIndex best_position;
3405 int tile_count;
3406
3407 StatueBuildSearchData(TileIndex best_pos, int count) : best_position(best_pos), tile_count(count) { }
3408};
3409
3416 static bool SearchTileForStatue(TileIndex tile, void *user_data)
3417{
3418 static const int STATUE_NUMBER_INNER_TILES = 25; // Number of tiles int the center of the city, where we try to protect houses.
3419
3420 StatueBuildSearchData *statue_data = (StatueBuildSearchData *)user_data;
3421 statue_data->tile_count++;
3422
3423 /* Statues can be build on slopes, just like houses. Only the steep slopes is a no go. */
3424 if (IsSteepSlope(GetTileSlope(tile))) return false;
3425 /* Don't build statues under bridges. */
3426 if (IsBridgeAbove(tile)) return false;
3427
3428 /* A clear-able open space is always preferred. */
3429 if ((IsTileType(tile, MP_CLEAR) || IsTileType(tile, MP_TREES)) && CheckClearTile(tile)) {
3430 statue_data->best_position = tile;
3431 return true;
3432 }
3433
3434 bool house = IsTileType(tile, MP_HOUSE);
3435
3436 /* Searching inside the inner circle. */
3437 if (statue_data->tile_count <= STATUE_NUMBER_INNER_TILES) {
3438 /* Save first house in inner circle. */
3439 if (house && statue_data->best_position == INVALID_TILE && CheckClearTile(tile)) {
3440 statue_data->best_position = tile;
3441 }
3442
3443 /* If we have reached the end of the inner circle, and have a saved house, terminate the search. */
3444 return statue_data->tile_count == STATUE_NUMBER_INNER_TILES && statue_data->best_position != INVALID_TILE;
3445 }
3446
3447 /* Searching outside the circle, just pick the first possible spot. */
3448 statue_data->best_position = tile; // Is optimistic, the condition below must also hold.
3449 return house && CheckClearTile(tile);
3450}
3451
3459 static CommandCost TownActionBuildStatue(Town *t, DoCommandFlag flags)
3460{
3461 if (!Object::CanAllocateItem()) return CommandCost(STR_ERROR_TOO_MANY_OBJECTS);
3462
3463 TileIndex tile = t->xy;
3464 StatueBuildSearchData statue_data(INVALID_TILE, 0);
3465 if (!CircularTileSearch(&tile, 9, SearchTileForStatue, &statue_data)) return CommandCost(STR_ERROR_STATUE_NO_SUITABLE_PLACE);
3466
3467 if (flags & DC_EXEC) {
3468 Backup<CompanyID> cur_company(_current_company, OWNER_NONE);
3469 Command<CMD_LANDSCAPE_CLEAR>::Do(DC_EXEC, statue_data.best_position);
3470 cur_company.Restore();
3471 BuildObject(OBJECT_STATUE, statue_data.best_position, _current_company, t);
3472 SetBit(t->statues, _current_company); // Once found and built, "inform" the Town.
3473 MarkTileDirtyByTile(statue_data.best_position);
3474 }
3475 return CommandCost();
3476}
3477
3484 static CommandCost TownActionFundBuildings(Town *t, DoCommandFlag flags)
3485{
3486 /* Check if it's allowed to buy the rights */
3487 if (!_settings_game.economy.fund_buildings) return CMD_ERROR;
3488
3489 if (flags & DC_EXEC) {
3490 /* And grow for 3 months */
3491 t->fund_buildings_months = 3;
3492
3493 /* Enable growth (also checking GameScript's opinion) */
3494 UpdateTownGrowth(t);
3495
3496 /* Build a new house, but add a small delay to make sure
3497 * that spamming funding doesn't let town grow any faster
3498 * than 1 house per 2 * TOWN_GROWTH_TICKS ticks.
3499 * Also emulate original behaviour when town was only growing in
3500 * TOWN_GROWTH_TICKS intervals, to make sure that it's not too
3501 * tick-perfect and gives player some time window where they can
3502 * spam funding with the exact same efficiency.
3503 */
3504 t->grow_counter = std::min<uint16_t>(t->grow_counter, 2 * Ticks::TOWN_GROWTH_TICKS - (t->growth_rate - t->grow_counter) % Ticks::TOWN_GROWTH_TICKS);
3505
3506 SetWindowDirty(WC_TOWN_VIEW, t->index);
3507 }
3508 return CommandCost();
3509}
3510
3517 static CommandCost TownActionBuyRights(Town *t, DoCommandFlag flags)
3518{
3519 /* Check if it's allowed to buy the rights */
3520 if (!_settings_game.economy.exclusive_rights) return CMD_ERROR;
3521 if (t->exclusivity != INVALID_COMPANY) return CMD_ERROR;
3522
3523 if (flags & DC_EXEC) {
3524 t->exclusive_counter = 12;
3525 t->exclusivity = _current_company;
3526
3527 ModifyStationRatingAround(t->xy, _current_company, 130, 17);
3528
3529 SetWindowClassesDirty(WC_STATION_VIEW);
3530
3531 /* Spawn news message */
3532 auto cni = std::make_unique<CompanyNewsInformation>(Company::Get(_current_company));
3533 SetDParam(0, STR_NEWS_EXCLUSIVE_RIGHTS_TITLE);
3534 SetDParam(1, TimerGameEconomy::UsingWallclockUnits() ? STR_NEWS_EXCLUSIVE_RIGHTS_DESCRIPTION_MINUTES : STR_NEWS_EXCLUSIVE_RIGHTS_DESCRIPTION_MONTHS);
3535 SetDParam(2, t->index);
3536 SetDParamStr(3, cni->company_name);
3537 AddNewsItem(STR_MESSAGE_NEWS_FORMAT, NT_GENERAL, NF_COMPANY, NR_TOWN, t->index, NR_NONE, UINT32_MAX, std::move(cni));
3538 AI::BroadcastNewEvent(new ScriptEventExclusiveTransportRights((ScriptCompany::CompanyID)(Owner)_current_company, t->index));
3539 Game::NewEvent(new ScriptEventExclusiveTransportRights((ScriptCompany::CompanyID)(Owner)_current_company, t->index));
3540 }
3541 return CommandCost();
3542}
3543
3550 static CommandCost TownActionBribe(Town *t, DoCommandFlag flags)
3551{
3552 if (flags & DC_EXEC) {
3553 if (Chance16(1, 14)) {
3554 /* set as unwanted for 6 months */
3555 t->unwanted[_current_company] = 6;
3556
3557 /* set all close by station ratings to 0 */
3558 for (Station *st : Station::Iterate()) {
3559 if (st->town == t && st->owner == _current_company) {
3560 for (GoodsEntry &ge : st->goods) ge.rating = 0;
3561 }
3562 }
3563
3564 /* only show error message to the executing player. All errors are handled command.c
3565 * but this is special, because it can only 'fail' on a DC_EXEC */
3566 if (IsLocalCompany()) ShowErrorMessage(STR_ERROR_BRIBE_FAILED, INVALID_STRING_ID, WL_INFO);
3567
3568 /* decrease by a lot!
3569 * ChangeTownRating is only for stuff in demolishing. Bribe failure should
3570 * be independent of any cheat settings
3571 */
3572 if (t->ratings[_current_company] > RATING_BRIBE_DOWN_TO) {
3573 t->ratings[_current_company] = RATING_BRIBE_DOWN_TO;
3574 SetWindowDirty(WC_TOWN_AUTHORITY, t->index);
3575 }
3576 } else {
3577 ChangeTownRating(t, RATING_BRIBE_UP_STEP, RATING_BRIBE_MAXIMUM, DC_EXEC);
3578 if (t->exclusivity != _current_company && t->exclusivity != INVALID_COMPANY) {
3579 t->exclusivity = INVALID_COMPANY;
3580 t->exclusive_counter = 0;
3581 }
3582 }
3583 }
3584 return CommandCost();
3585}
3586
3587typedef CommandCost TownActionProc(Town *t, DoCommandFlag flags);
3588static TownActionProc * const _town_action_proc[] = {
3589 TownActionAdvertiseSmall,
3590 TownActionAdvertiseMedium,
3591 TownActionAdvertiseLarge,
3592 TownActionRoadRebuild,
3593 TownActionBuildStatue,
3594 TownActionFundBuildings,
3595 TownActionBuyRights,
3596 TownActionBribe
3597};
3598
3605 TownActions GetMaskOfTownActions(CompanyID cid, const Town *t)
3606{
3607 TownActions buttons = TACT_NONE;
3608
3609 /* Spectators and unwanted have no options */
3610 if (cid != COMPANY_SPECTATOR && !(_settings_game.economy.bribe && t->unwanted[cid])) {
3611
3612 /* Actions worth more than this are not able to be performed */
3613 Money avail = GetAvailableMoney(cid);
3614
3615 /* Check the action bits for validity and
3616 * if they are valid add them */
3617 for (uint i = 0; i != lengthof(_town_action_costs); i++) {
3618 const TownActions cur = (TownActions)(1 << i);
3619
3620 /* Is the company prohibited from bribing ? */
3621 if (cur == TACT_BRIBE) {
3622 /* Company can't bribe if setting is disabled */
3623 if (!_settings_game.economy.bribe) continue;
3624 /* Company can bribe if another company has exclusive transport rights,
3625 * or its standing with the town is less than outstanding. */
3626 if (t->ratings[cid] >= RATING_BRIBE_MAXIMUM) {
3627 if (t->exclusivity == _current_company) continue;
3628 if (t->exclusive_counter == 0) continue;
3629 }
3630 }
3631
3632 /* Is the company not able to buy exclusive rights ? */
3633 if (cur == TACT_BUY_RIGHTS && (!_settings_game.economy.exclusive_rights || t->exclusive_counter != 0)) continue;
3634
3635 /* Is the company not able to fund buildings ? */
3636 if (cur == TACT_FUND_BUILDINGS && !_settings_game.economy.fund_buildings) continue;
3637
3638 /* Is the company not able to fund local road reconstruction? */
3639 if (cur == TACT_ROAD_REBUILD && !_settings_game.economy.fund_roads) continue;
3640
3641 /* Is the company not able to build a statue ? */
3642 if (cur == TACT_BUILD_STATUE && HasBit(t->statues, cid)) continue;
3643
3644 if (avail >= _town_action_costs[i] * _price[PR_TOWN_ACTION] >> 8) {
3645 buttons |= cur;
3646 }
3647 }
3648 }
3649
3650 return buttons;
3651}
3652
3662 CommandCost CmdDoTownAction(DoCommandFlag flags, TownID town_id, uint8_t action)
3663{
3664 Town *t = Town::GetIfValid(town_id);
3665 if (t == nullptr || action >= lengthof(_town_action_proc)) return CMD_ERROR;
3666
3667 if (!HasBit(GetMaskOfTownActions(_current_company, t), action)) return CMD_ERROR;
3668
3669 CommandCost cost(EXPENSES_OTHER, _price[PR_TOWN_ACTION] * _town_action_costs[action] >> 8);
3670
3671 CommandCost ret = _town_action_proc[action](t, flags);
3672 if (ret.Failed()) return ret;
3673
3674 if (flags & DC_EXEC) {
3675 SetWindowDirty(WC_TOWN_AUTHORITY, town_id);
3676 }
3677
3678 return cost;
3679}
3680
3681template <typename Func>
3682static void ForAllStationsNearTown(Town *t, Func func)
3683{
3684 /* Ideally the search radius should be close to the actual town zone 0 radius.
3685 * The true radius is not stored or calculated anywhere, only the squared radius. */
3686 /* The efficiency of this search might be improved for large towns and many stations on the map,
3687 * by using an integer square root approximation giving a value not less than the true square root. */
3688 uint search_radius = t->cache.squared_town_zone_radius[HZB_TOWN_EDGE] / 2;
3689 ForAllStationsRadius(t->xy, search_radius, [&](const Station * st) {
3690 if (DistanceSquare(st->xy, t->xy) <= t->cache.squared_town_zone_radius[HZB_TOWN_EDGE]) {
3691 func(st);
3692 }
3693 });
3694}
3695
3700 static void UpdateTownRating(Town *t)
3701{
3702 /* Increase company ratings if they're low */
3703 for (const Company *c : Company::Iterate()) {
3704 if (t->ratings[c->index] < RATING_GROWTH_MAXIMUM) {
3705 t->ratings[c->index] = std::min((int)RATING_GROWTH_MAXIMUM, t->ratings[c->index] + RATING_GROWTH_UP_STEP);
3706 }
3707 }
3708
3709 ForAllStationsNearTown(t, [&](const Station *st) {
3710 if (st->time_since_load <= 20 || st->time_since_unload <= 20) {
3711 if (Company::IsValidID(st->owner)) {
3712 int new_rating = t->ratings[st->owner] + RATING_STATION_UP_STEP;
3713 t->ratings[st->owner] = std::min<int>(new_rating, INT16_MAX); // do not let it overflow
3714 }
3715 } else {
3716 if (Company::IsValidID(st->owner)) {
3717 int new_rating = t->ratings[st->owner] + RATING_STATION_DOWN_STEP;
3718 t->ratings[st->owner] = std::max(new_rating, INT16_MIN);
3719 }
3720 }
3721 });
3722
3723 /* clamp all ratings to valid values */
3724 for (uint i = 0; i < MAX_COMPANIES; i++) {
3725 t->ratings[i] = Clamp(t->ratings[i], RATING_MINIMUM, RATING_MAXIMUM);
3726 }
3727
3728 SetWindowDirty(WC_TOWN_AUTHORITY, t->index);
3729}
3730
3731
3738 static void UpdateTownGrowCounter(Town *t, uint16_t prev_growth_rate)
3739{
3740 if (t->growth_rate == TOWN_GROWTH_RATE_NONE) return;
3741 if (prev_growth_rate == TOWN_GROWTH_RATE_NONE) {
3742 t->grow_counter = std::min<uint16_t>(t->growth_rate, t->grow_counter);
3743 return;
3744 }
3745 t->grow_counter = RoundDivSU((uint32_t)t->grow_counter * (t->growth_rate + 1), prev_growth_rate + 1);
3746}
3747
3753 static int CountActiveStations(Town *t)
3754{
3755 int n = 0;
3756 ForAllStationsNearTown(t, [&](const Station * st) {
3757 if (st->time_since_load <= 20 || st->time_since_unload <= 20) {
3758 n++;
3759 }
3760 });
3761 return n;
3762}
3763
3770 static uint GetNormalGrowthRate(Town *t)
3771{
3777 static const uint16_t _grow_count_values[2][6] = {
3778 { 120, 120, 120, 100, 80, 60 }, // Fund new buildings has been activated
3779 { 320, 420, 300, 220, 160, 100 } // Normal values
3780 };
3781
3782 int n = CountActiveStations(t);
3783 uint16_t m = _grow_count_values[t->fund_buildings_months != 0 ? 0 : 1][std::min(n, 5)];
3784
3785 uint growth_multiplier = _settings_game.economy.town_growth_rate != 0 ? _settings_game.economy.town_growth_rate - 1 : 1;
3786
3787 m >>= growth_multiplier;
3788 if (t->larger_town) m /= 2;
3789
3790 return TownTicksToGameTicks(m / (t->cache.num_houses / 50 + 1));
3791}
3792
3797 static void UpdateTownGrowthRate(Town *t)
3798{
3799 if (HasBit(t->flags, TOWN_CUSTOM_GROWTH)) return;
3800 uint old_rate = t->growth_rate;
3801 t->growth_rate = GetNormalGrowthRate(t);
3802 UpdateTownGrowCounter(t, old_rate);
3803 SetWindowDirty(WC_TOWN_VIEW, t->index);
3804}
3805
3810 static void UpdateTownGrowth(Town *t)
3811{
3812 UpdateTownGrowthRate(t);
3813
3814 ClrBit(t->flags, TOWN_IS_GROWING);
3815 SetWindowDirty(WC_TOWN_VIEW, t->index);
3816
3817 if (_settings_game.economy.town_growth_rate == 0 && t->fund_buildings_months == 0) return;
3818
3819 if (t->fund_buildings_months == 0) {
3820 /* Check if all goals are reached for this town to grow (given we are not funding it) */
3821 for (int i = TAE_BEGIN; i < TAE_END; i++) {
3822 switch (t->goal[i]) {
3823 case TOWN_GROWTH_WINTER:
3824 if (TileHeight(t->xy) >= GetSnowLine() && t->received[i].old_act == 0 && t->cache.population > 90) return;
3825 break;
3826 case TOWN_GROWTH_DESERT:
3827 if (GetTropicZone(t->xy) == TROPICZONE_DESERT && t->received[i].old_act == 0 && t->cache.population > 60) return;
3828 break;
3829 default:
3830 if (t->goal[i] > t->received[i].old_act) return;
3831 break;
3832 }
3833 }
3834 }
3835
3836 if (HasBit(t->flags, TOWN_CUSTOM_GROWTH)) {
3837 if (t->growth_rate != TOWN_GROWTH_RATE_NONE) SetBit(t->flags, TOWN_IS_GROWING);
3838 SetWindowDirty(WC_TOWN_VIEW, t->index);
3839 return;
3840 }
3841
3842 if (t->fund_buildings_months == 0 && CountActiveStations(t) == 0 && !Chance16(1, 12)) return;
3843
3844 SetBit(t->flags, TOWN_IS_GROWING);
3845 SetWindowDirty(WC_TOWN_VIEW, t->index);
3846}
3847
3854 CommandCost CheckIfAuthorityAllowsNewStation(TileIndex tile, DoCommandFlag flags)
3855{
3856 /* The required rating is hardcoded to RATING_VERYPOOR (see below), not the authority attitude setting, so we can bail out like this. */
3857 if (_settings_game.difficulty.town_council_tolerance == TOWN_COUNCIL_PERMISSIVE) return CommandCost();
3858
3859 if (!Company::IsValidID(_current_company) || (flags & DC_NO_TEST_TOWN_RATING)) return CommandCost();
3860
3861 Town *t = ClosestTownFromTile(tile, _settings_game.economy.dist_local_authority);
3862 if (t == nullptr) return CommandCost();
3863
3864 if (t->ratings[_current_company] > RATING_VERYPOOR) return CommandCost();
3865
3866 SetDParam(0, t->index);
3867 return CommandCost(STR_ERROR_LOCAL_AUTHORITY_REFUSES_TO_ALLOW_THIS);
3868}
3869
3878 Town *CalcClosestTownFromTile(TileIndex tile, uint threshold)
3879{
3880 if (Town::GetNumItems() == 0) return nullptr;
3881
3882 TownID tid = _town_kdtree.FindNearest(TileX(tile), TileY(tile));
3883 Town *town = Town::Get(tid);
3884 if (DistanceManhattan(tile, town->xy) < threshold) return town;
3885 return nullptr;
3886}
3887
3896 Town *ClosestTownFromTile(TileIndex tile, uint threshold)
3897{
3898 switch (GetTileType(tile)) {
3899 case MP_ROAD:
3900 if (IsRoadDepot(tile)) return CalcClosestTownFromTile(tile, threshold);
3901
3902 if (!HasTownOwnedRoad(tile)) {
3903 TownID tid = GetTownIndex(tile);
3904
3905 if (tid == INVALID_TOWN) {
3906 /* in the case we are generating "many random towns", this value may be INVALID_TOWN */
3907 if (_generating_world) return CalcClosestTownFromTile(tile, threshold);
3908 assert(Town::GetNumItems() == 0);
3909 return nullptr;
3910 }
3911
3912 assert(Town::IsValidID(tid));
3913 Town *town = Town::Get(tid);
3914
3915 if (DistanceManhattan(tile, town->xy) >= threshold) town = nullptr;
3916
3917 return town;
3918 }
3919 [[fallthrough]];
3920
3921 case MP_HOUSE:
3922 return Town::GetByTile(tile);
3923
3924 default:
3925 return CalcClosestTownFromTile(tile, threshold);
3926 }
3927}
3928
3929 static bool _town_rating_test = false;
3930 static std::map<const Town *, int> _town_test_ratings;
3931
3937 void SetTownRatingTestMode(bool mode)
3938{
3939 static int ref_count = 0; // Number of times test-mode is switched on.
3940 if (mode) {
3941 if (ref_count == 0) {
3942 _town_test_ratings.clear();
3943 }
3944 ref_count++;
3945 } else {
3946 assert(ref_count > 0);
3947 ref_count--;
3948 }
3949 _town_rating_test = !(ref_count == 0);
3950}
3951
3957 static int GetRating(const Town *t)
3958{
3959 if (_town_rating_test) {
3960 auto it = _town_test_ratings.find(t);
3961 if (it != _town_test_ratings.end()) {
3962 return it->second;
3963 }
3964 }
3965 return t->ratings[_current_company];
3966}
3967
3975 void ChangeTownRating(Town *t, int add, int max, DoCommandFlag flags)
3976{
3977 /* if magic_bulldozer cheat is active, town doesn't penalize for removing stuff */
3978 if (t == nullptr || (flags & DC_NO_MODIFY_TOWN_RATING) ||
3979 !Company::IsValidID(_current_company) ||
3980 (_cheats.magic_bulldozer.value && add < 0)) {
3981 return;
3982 }
3983
3984 int rating = GetRating(t);
3985 if (add < 0) {
3986 if (rating > max) {
3987 rating += add;
3988 if (rating < max) rating = max;
3989 }
3990 } else {
3991 if (rating < max) {
3992 rating += add;
3993 if (rating > max) rating = max;
3994 }
3995 }
3996 if (_town_rating_test) {
3997 _town_test_ratings[t] = rating;
3998 } else {
3999 SetBit(t->have_ratings, _current_company);
4000 t->ratings[_current_company] = rating;
4001 SetWindowDirty(WC_TOWN_AUTHORITY, t->index);
4002 }
4003}
4004
4012 CommandCost CheckforTownRating(DoCommandFlag flags, Town *t, TownRatingCheckType type)
4013{
4014 /* if magic_bulldozer cheat is active, town doesn't restrict your destructive actions */
4015 if (t == nullptr || !Company::IsValidID(_current_company) ||
4016 _cheats.magic_bulldozer.value || (flags & DC_NO_TEST_TOWN_RATING)) {
4017 return CommandCost();
4018 }
4019
4020 /* minimum rating needed to be allowed to remove stuff */
4021 static const int needed_rating[][TOWN_RATING_CHECK_TYPE_COUNT] = {
4022 /* ROAD_REMOVE, TUNNELBRIDGE_REMOVE */
4023 { RATING_ROAD_NEEDED_LENIENT, RATING_TUNNEL_BRIDGE_NEEDED_LENIENT}, // Lenient
4024 { RATING_ROAD_NEEDED_NEUTRAL, RATING_TUNNEL_BRIDGE_NEEDED_NEUTRAL}, // Neutral
4025 { RATING_ROAD_NEEDED_HOSTILE, RATING_TUNNEL_BRIDGE_NEEDED_HOSTILE}, // Hostile
4026 { RATING_ROAD_NEEDED_PERMISSIVE, RATING_TUNNEL_BRIDGE_NEEDED_PERMISSIVE}, // Permissive
4027 };
4028
4029 /* check if you're allowed to remove the road/bridge/tunnel
4030 * owned by a town no removal if rating is lower than ... depends now on
4031 * difficulty setting. Minimum town rating selected by difficulty level
4032 */
4033 int needed = needed_rating[_settings_game.difficulty.town_council_tolerance][type];
4034
4035 if (GetRating(t) < needed) {
4036 SetDParam(0, t->index);
4037 return CommandCost(STR_ERROR_LOCAL_AUTHORITY_REFUSES_TO_ALLOW_THIS);
4038 }
4039
4040 return CommandCost();
4041}
4042
4043static IntervalTimer<TimerGameEconomy> _economy_towns_monthly({TimerGameEconomy::MONTH, TimerGameEconomy::Priority::TOWN}, [](auto)
4044{
4045 for (Town *t : Town::Iterate()) {
4046 /* Check for active town actions and decrement their counters. */
4047 if (t->road_build_months != 0) t->road_build_months--;
4048 if (t->fund_buildings_months != 0) t->fund_buildings_months--;
4049
4050 if (t->exclusive_counter != 0) {
4051 if (--t->exclusive_counter == 0) t->exclusivity = INVALID_COMPANY;
4052 }
4053
4054 /* Check for active failed bribe cooloff periods and decrement them. */
4055 for (const Company *c : Company::Iterate()) {
4056 if (t->unwanted[c->index] > 0) t->unwanted[c->index]--;
4057 }
4058
4059 /* Update cargo statistics. */
4060 for (auto &supplied : t->supplied) supplied.NewMonth();
4061 for (auto &received : t->received) received.NewMonth();
4062
4063 UpdateTownGrowth(t);
4064 UpdateTownRating(t);
4065
4066 SetWindowDirty(WC_TOWN_VIEW, t->index);
4067 }
4068});
4069
4070static IntervalTimer<TimerGameEconomy> _economy_towns_yearly({TimerGameEconomy::YEAR, TimerGameEconomy::Priority::TOWN}, [](auto)
4071{
4072 /* Increment house ages */
4073 for (const auto t : Map::Iterate()) {
4074 if (!IsTileType(t, MP_HOUSE)) continue;
4075 IncrementHouseAge(t);
4076 }
4077});
4078
4079static CommandCost TerraformTile_Town(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)
4080{
4081 if (AutoslopeEnabled()) {
4082 HouseID house = GetHouseType(tile);
4083 GetHouseNorthPart(house); // modifies house to the ID of the north tile
4084 const HouseSpec *hs = HouseSpec::Get(house);
4085
4086 /* Here we differ from TTDP by checking TILE_NOT_SLOPED */
4087 if (((hs->building_flags & TILE_NOT_SLOPED) == 0) && !IsSteepSlope(tileh_new) &&
4088 (GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new))) {
4089 bool allow_terraform = true;
4090
4091 /* Call the autosloping callback per tile, not for the whole building at once. */
4092 house = GetHouseType(tile);
4093 hs = HouseSpec::Get(house);
4094 if (HasBit(hs->callback_mask, CBM_HOUSE_AUTOSLOPE)) {
4095 /* If the callback fails, allow autoslope. */
4096 uint16_t res = GetHouseCallback(CBID_HOUSE_AUTOSLOPE, 0, 0, house, Town::GetByTile(tile), tile);
4097 if (res != CALLBACK_FAILED && ConvertBooleanCallback(hs->grf_prop.grffile, CBID_HOUSE_AUTOSLOPE, res)) allow_terraform = false;
4098 }
4099
4100 if (allow_terraform) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
4101 }
4102 }
4103
4104 return Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
4105}
4106
4108extern const TileTypeProcs _tile_type_town_procs = {
4109 DrawTile_Town, // draw_tile_proc
4110 GetSlopePixelZ_Town, // get_slope_z_proc
4111 ClearTile_Town, // clear_tile_proc
4112 AddAcceptedCargo_Town, // add_accepted_cargo_proc
4113 GetTileDesc_Town, // get_tile_desc_proc
4114 GetTileTrackStatus_Town, // get_tile_track_status_proc
4115 nullptr, // click_tile_proc
4116 AnimateTile_Town, // animate_tile_proc
4117 TileLoop_Town, // tile_loop_proc
4118 ChangeTileOwner_Town, // change_tile_owner_proc
4119 AddProducedCargo_Town, // add_produced_cargo_proc
4120 nullptr, // vehicle_enter_tile_proc
4121 GetFoundation_Town, // get_foundation_proc
4122 TerraformTile_Town, // terraform_tile_proc
4123};
4124
4125std::span<const DrawBuildingsTileStruct> GetTownDrawTileData()
4126{
4127 return _town_draw_tile_data;
4128}
ai.hpp
Base functions for all AIs.
AT_OILRIG
@ AT_OILRIG
Oilrig airport.
Definition airport.h:38
AddAnimatedTile
void AddAnimatedTile(TileIndex tile, bool mark_dirty)
Add the given tile to the animated tile table (if it does not exist yet).
Definition animated_tile.cpp:56
DeleteAnimatedTile
void DeleteAnimatedTile(TileIndex tile, bool immediate)
Stops animation on the given tile.
Definition animated_tile.cpp:27
animated_tile_func.h
Tile animation!
autoslope.h
Functions related to autoslope.
AutoslopeEnabled
bool AutoslopeEnabled()
Tests if autoslope is enabled for _current_company.
Definition autoslope.h:65
backup_type.hpp
Class for backupping variables and making sure they are restored later.
HasBit
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition bitmath_func.hpp:103
SetBit
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
Definition bitmath_func.hpp:121
CountBits
constexpr uint CountBits(T value)
Counts the number of set bits in a variable.
Definition bitmath_func.hpp:262
GB
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.
Definition bitmath_func.hpp:32
ClrBit
constexpr T ClrBit(T &x, const uint8_t y)
Clears a bit in a variable.
Definition bitmath_func.hpp:151
MAX_BRIDGES
static const uint MAX_BRIDGES
Maximal number of available bridge specs.
Definition bridge.h:35
IsBridgeTile
bool IsBridgeTile(Tile t)
checks if there is a bridge on this tile
Definition bridge_map.h:35
IsBridgeAbove
bool IsBridgeAbove(Tile t)
checks if a bridge is set above the ground of this tile
Definition bridge_map.h:45
GetBridgeAxis
Axis GetBridgeAxis(Tile t)
Get the axis of the bridge that goes over the tile.
Definition bridge_map.h:68
CargoID
uint8_t CargoID
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:22
IsValidCargoID
bool IsValidCargoID(CargoID t)
Test whether cargo type is not INVALID_CARGO.
Definition cargo_type.h:107
SourceType::Town
@ Town
Source/destination is a town.
TownProductionEffect
TownProductionEffect
Town effect when producing cargo.
Definition cargotype.h:34
TPE_PASSENGERS
@ TPE_PASSENGERS
Cargo behaves passenger-like for production.
Definition cargotype.h:36
TPE_MAIL
@ TPE_MAIL
Cargo behaves mail-like for production.
Definition cargotype.h:37
TownAcceptanceEffect
TownAcceptanceEffect
Town growth effect when delivering cargo.
Definition cargotype.h:21
TAE_END
@ TAE_END
End of town effects.
Definition cargotype.h:29
TAE_FOOD
@ TAE_FOOD
Cargo behaves food/fizzy-drinks-like.
Definition cargotype.h:28
TAE_WATER
@ TAE_WATER
Cargo behaves water-like.
Definition cargotype.h:27
_cheats
Cheats _cheats
All the cheats.
Definition cheat.cpp:16
cheat_type.h
Types related to cheating.
AI::BroadcastNewEvent
static void BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company=MAX_COMPANIES)
Broadcast a new event to all active AIs.
Definition ai_core.cpp:263
CommandCost
Common return value for all commands.
Definition command_type.h:23
CommandCost::Succeeded
bool Succeeded() const
Did this command succeed?
Definition command_type.h:162
CommandCost::AddCost
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
Definition command_type.h:63
CommandCost::GetCost
Money GetCost() const
The costs as made up to this moment.
Definition command_type.h:83
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition command_type.h:171
CommandCost::MultiplyCost
void MultiplyCost(int factor)
Multiplies the cost of the command by the given factor.
Definition command_type.h:74
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition game_core.cpp:146
IntervalTimer
An interval timer will fire every interval, and will continue to fire until it is deleted.
Definition timer.h:76
Kdtree
K-dimensional tree, specialised for 2-dimensional space.
Definition kdtree.hpp:35
Kdtree::Build
void Build(It begin, It end)
Clear and rebuild the tree from a new sequence of elements,.
Definition kdtree.hpp:362
Kdtree::Count
size_t Count() const
Get number of elements stored in tree.
Definition kdtree.hpp:430
Kdtree::Insert
void Insert(const T &element)
Insert a single element in the tree.
Definition kdtree.hpp:398
Kdtree::Remove
void Remove(const T &element)
Remove a single element from the tree, if it exists.
Definition kdtree.hpp:417
Kdtree::FindNearest
T FindNearest(CoordT x, CoordT y) const
Find the element closest to given coordinate, in Manhattan distance.
Definition kdtree.hpp:441
OverflowSafeInt< int64_t >
RoadTypeInfo
Definition road.h:78
RoadTypeInfo::label
RoadTypeLabel label
Unique 32 bit road type identifier.
Definition road.h:147
RoadTypeInfo::introduction_date
TimerGameCalendar::Date introduction_date
Introduction date.
Definition road.h:166
RoadTypeInfo::flags
RoadTypeFlags flags
Bit mask of road type flags.
Definition road.h:127
RoadTypeInfo::max_speed
uint16_t max_speed
Maximum speed for vehicles travelling on this road type.
Definition road.h:142
StationFinder
Structure contains cached list of stations nearby.
Definition station_type.h:100
StationFinder::GetStations
const StationList & GetStations()
Run a tile loop to find stations around a tile, on demand.
Definition station_cmd.cpp:4354
Ticks::TOWN_GROWTH_TICKS
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).
Definition timer_game_tick.h:83
TimerGameCalendar::date
static Date date
Current date in days (day counter).
Definition timer_game_calendar.h:33
TimerGameCalendar::year
static Year year
Current year, starting at 0.
Definition timer_game_calendar.h:31
TimerGameConst< struct Calendar >::MAX_DATE
static constexpr TimerGame< struct Calendar >::Date MAX_DATE
The date of the last day of the max year.
Definition timer_game_common.h:187
TimerGameEconomy::UsingWallclockUnits
static bool UsingWallclockUnits(bool newgame=false)
Check if we are using wallclock units.
Definition timer_game_economy.cpp:97
TimerGameTick::counter
static TickCounter counter
Monotonic counter, in ticks, since start of game.
Definition timer_game_tick.h:60
command_func.h
Functions related to commands.
CommandFlagsToDCFlags
static constexpr DoCommandFlag CommandFlagsToDCFlags(CommandFlags cmd_flags)
Extracts the DC flags needed for DoCommand from the flags returned by GetCommandFlags.
Definition command_func.h:48
CMD_ERROR
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition command_func.h:28
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition command_type.h:374
DC_NONE
@ DC_NONE
no flag is set
Definition command_type.h:375
DC_NO_TEST_TOWN_RATING
@ DC_NO_TEST_TOWN_RATING
town rating does not disallow you from building
Definition command_type.h:381
DC_AUTO
@ DC_AUTO
don't allow building on structures
Definition command_type.h:377
DC_NO_WATER
@ DC_NO_WATER
don't allow building on water
Definition command_type.h:379
DC_NO_MODIFY_TOWN_RATING
@ DC_NO_MODIFY_TOWN_RATING
do not change town rating
Definition command_type.h:386
DC_EXEC
@ DC_EXEC
execute the given command
Definition command_type.h:376
company_base.h
Definition of stuff that is very close to a company, like the company struct itself.
GetAvailableMoneyForCommand
Money GetAvailableMoneyForCommand()
This functions returns the money which can be used to execute a command.
Definition company_cmd.cpp:230
GetAvailableMoney
Money GetAvailableMoney(CompanyID company)
Get the amount of money that a company has available, or INT64_MAX if there is no such valid company.
Definition company_cmd.cpp:216
_current_company
CompanyID _current_company
Company currently doing an action.
Definition company_cmd.cpp:53
company_func.h
Functions related to companies.
IsLocalCompany
bool IsLocalCompany()
Is the current company the local company?
Definition company_func.h:47
Owner
Owner
Enum for all companies/owners.
Definition company_type.h:18
INVALID_COMPANY
@ INVALID_COMPANY
An invalid company.
Definition company_type.h:30
COMPANY_SPECTATOR
@ COMPANY_SPECTATOR
The client is spectating.
Definition company_type.h:35
OWNER_DEITY
@ OWNER_DEITY
The object is owned by a superuser / goal script.
Definition company_type.h:27
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition company_type.h:25
OWNER_TOWN
@ OWNER_TOWN
A town owns the tile, or a town is expanding.
Definition company_type.h:24
MAX_COMPANIES
@ MAX_COMPANIES
Maximum number of companies.
Definition company_type.h:23
depot_base.h
Base for all depots (except hangars)
ReverseDiagDir
DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
Definition direction_func.h:118
IsValidDiagDirection
bool IsValidDiagDirection(DiagDirection d)
Checks if an integer value is a valid DiagDirection.
Definition direction_func.h:21
ChangeDiagDir
DiagDirection ChangeDiagDir(DiagDirection d, DiagDirDiff delta)
Applies a difference on a DiagDirection.
Definition direction_func.h:149
DiagDirToAxis
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
Definition direction_func.h:214
DIR_N
@ DIR_N
North.
Definition direction_type.h:26
DIR_S
@ DIR_S
South.
Definition direction_type.h:30
DIR_W
@ DIR_W
West.
Definition direction_type.h:32
DIR_E
@ DIR_E
East.
Definition direction_type.h:28
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition direction_type.h:73
DIAGDIR_NW
@ DIAGDIR_NW
Northwest.
Definition direction_type.h:78
DIAGDIR_SE
@ DIAGDIR_SE
Southeast.
Definition direction_type.h:76
DIAGDIR_END
@ DIAGDIR_END
Used for iterations.
Definition direction_type.h:79
DIAGDIR_BEGIN
@ DIAGDIR_BEGIN
Used for iterations.
Definition direction_type.h:74
DIAGDIR_SW
@ DIAGDIR_SW
Southwest.
Definition direction_type.h:77
DIAGDIRDIFF_90RIGHT
@ DIAGDIRDIFF_90RIGHT
90 degrees right
Definition direction_type.h:98
DIAGDIRDIFF_90LEFT
@ DIAGDIRDIFF_90LEFT
90 degrees left
Definition direction_type.h:100
EconomyIsInRecession
bool EconomyIsInRecession()
Is the economy in recession?
Definition economy_func.h:49
ScaleByCargoScale
uint ScaleByCargoScale(uint num, bool town)
Scale a number by the cargo scale setting.
Definition economy_func.h:77
EXPENSES_CONSTRUCTION
@ EXPENSES_CONSTRUCTION
Construction costs.
Definition economy_type.h:173
EXPENSES_OTHER
@ EXPENSES_OTHER
Other expenses.
Definition economy_type.h:185
error.h
Functions related to errors.
ShowErrorMessage
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
Definition error_gui.cpp:367
WL_CRITICAL
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
Definition error.h:27
WL_INFO
@ WL_INFO
Used for DoCommand-like (and some non-fatal AI GUI) errors/information.
Definition error.h:24
game.hpp
Base functions for all Games.
_generating_world
bool _generating_world
Whether we are generating the map or not.
Definition genworld.cpp:67
genworld.h
Functions related to world/map generation.
IncreaseGeneratingWorldProgress
void IncreaseGeneratingWorldProgress(GenWorldProgress cls)
Increases the current stage of the world generation with one.
Definition genworld_gui.cpp:1547
GWP_TOWN
@ GWP_TOWN
Generate towns.
Definition genworld.h:74
SetGeneratingWorldProgress
void SetGeneratingWorldProgress(GenWorldProgress cls, uint total)
Set the total of a stage of the world generation.
Definition genworld_gui.cpp:1533
SpriteID
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:18
GetSnowLine
uint8_t GetSnowLine()
Get the current snow line, either variable or static.
Definition landscape.cpp:609
HighestSnowLine
uint8_t HighestSnowLine()
Get the highest possible snow line height, either variable or static.
Definition landscape.cpp:622
MarkWholeScreenDirty
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition gfx.cpp:1529
MarkTileDirtyByTile
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
Definition viewport.cpp:2057
NEW_HOUSE_OFFSET
static const HouseID NEW_HOUSE_OFFSET
Offset for new houses.
Definition house.h:26
TOWN_HOUSE_COMPLETED
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
@ BUILDING_IS_HISTORICAL
this house will only appear during town generation in random games, thus the historical
Definition house.h:85
HouseID
uint16_t HouseID
OpenTTD ID of house types.
Definition house_type.h:13
industry.h
Base of all industries.
DrawFoundation
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
Definition landscape.cpp:425
GetFoundationSlope
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,...
Definition landscape.cpp:382
landscape.h
Functions related to OTTD's landscape.
RemapCoords2
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
landscape_cmd.h
Command definitions related to landscape (slopes etc.).
CircularTileSearch
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
DistanceSquare
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
Definition map.cpp:163
DistanceFromEdge
uint DistanceFromEdge(TileIndex tile)
Param the minimum distance to an edge.
Definition map.cpp:206
DistanceManhattan
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition map.cpp:146
GetClosestWaterDistance
uint GetClosestWaterDistance(TileIndex tile, bool water)
Finds the distance for the closest tile with water/land given a tile.
Definition map.cpp:329
TileAddXY
TileIndex TileAddXY(TileIndex tile, int x, int y)
Adds a given offset to a tile.
Definition map_func.h:467
TileAddByDir
TileIndex TileAddByDir(TileIndex tile, Direction dir)
Adds a Direction to a tile.
Definition map_func.h:596
TileXY
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition map_func.h:373
ToTileIndexDiff
TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
Return the offset between two tiles from a TileIndexDiffC struct.
Definition map_func.h:440
TileAddByDiagDir
TileIndex TileAddByDiagDir(TileIndex tile, DiagDirection dir)
Adds a DiagDir to a tile.
Definition map_func.h:608
TileDiffXY
TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition map_func.h:389
TileAdd
constexpr TileIndex TileAdd(TileIndex tile, TileIndexDiff offset)
Adds a given offset to a tile.
Definition map_func.h:454
RandomTile
#define RandomTile()
Get a valid random tile.
Definition map_func.h:661
TileY
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:425
TileX
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:415
TileOffsByDiagDir
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition map_func.h:567
TileIndexToTileIndexDiffC
TileIndexDiffC TileIndexToTileIndexDiffC(TileIndex tile_a, TileIndex tile_b)
Returns the diff between two tiles.
Definition map_func.h:528
TileIndexDiff
int32_t TileIndexDiff
An offset value between two tiles.
Definition map_type.h:23
RoundDivSU
constexpr int RoundDivSU(int a, uint b)
Computes round(a / b) for signed a and unsigned b.
Definition math_func.hpp:342
Clamp
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition math_func.hpp:79
IsInsideMM
constexpr bool IsInsideMM(const T x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
Definition math_func.hpp:268
GSF_FAKE_TOWNS
@ GSF_FAKE_TOWNS
Fake town GrfSpecFeature for NewGRF debugging (parent scope)
Definition newgrf.h:91
CBID_HOUSE_DRAW_FOUNDATIONS
@ CBID_HOUSE_DRAW_FOUNDATIONS
Called to determine the type (if any) of foundation to draw for house tile.
Definition newgrf_callbacks.h:227
CBID_HOUSE_CARGO_ACCEPTANCE
@ CBID_HOUSE_CARGO_ACCEPTANCE
Called to decide how much cargo a town building can accept.
Definition newgrf_callbacks.h:78
CBID_HOUSE_AUTOSLOPE
@ CBID_HOUSE_AUTOSLOPE
Called to determine if one can alter the ground below a house tile.
Definition newgrf_callbacks.h:230
CBID_HOUSE_CUSTOM_NAME
@ CBID_HOUSE_CUSTOM_NAME
Called on the Get Tile Description for an house tile.
Definition newgrf_callbacks.h:224
CBID_HOUSE_ALLOW_CONSTRUCTION
@ CBID_HOUSE_ALLOW_CONSTRUCTION
Determine whether the house can be built on the specified tile.
Definition newgrf_callbacks.h:54
CBID_HOUSE_ACCEPT_CARGO
@ CBID_HOUSE_ACCEPT_CARGO
Called to determine which cargoes a town building should accept.
Definition newgrf_callbacks.h:114
CBID_HOUSE_PRODUCE_CARGO
@ CBID_HOUSE_PRODUCE_CARGO
Called to determine how much cargo a town building produces.
Definition newgrf_callbacks.h:129
CALLBACK_FAILED
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
Definition newgrf_callbacks.h:427
CALLBACK_HOUSEPRODCARGO_END
static const uint CALLBACK_HOUSEPRODCARGO_END
Sentinel indicating that the loop for CBID_HOUSE_PRODUCE_CARGO has ended.
Definition newgrf_callbacks.h:428
CBM_HOUSE_PRODUCE_CARGO
@ CBM_HOUSE_PRODUCE_CARGO
custom cargo production
Definition newgrf_callbacks.h:346
CBM_HOUSE_ALLOW_CONSTRUCTION
@ CBM_HOUSE_ALLOW_CONSTRUCTION
decide whether the house can be built on a given tile
Definition newgrf_callbacks.h:337
CBM_HOUSE_CARGO_ACCEPTANCE
@ CBM_HOUSE_CARGO_ACCEPTANCE
decides amount of cargo acceptance
Definition newgrf_callbacks.h:342
CBM_HOUSE_AUTOSLOPE
@ CBM_HOUSE_AUTOSLOPE
decides allowance of autosloping
Definition newgrf_callbacks.h:349
CBM_HOUSE_ACCEPT_CARGO
@ CBM_HOUSE_ACCEPT_CARGO
decides accepted types
Definition newgrf_callbacks.h:345
CBM_HOUSE_DRAW_FOUNDATIONS
@ CBM_HOUSE_DRAW_FOUNDATIONS
decides if default foundations need to be drawn
Definition newgrf_callbacks.h:348
GetCargoTranslation
CargoID GetCargoTranslation(uint8_t cargo, const GRFFile *grffile, bool usebit)
Translate a GRF-local cargo slot/bitnum into a CargoID.
Definition newgrf_cargo.cpp:80
newgrf_cargo.h
Cargo support for NewGRFs.
ErrorUnknownCallbackResult
void ErrorUnknownCallbackResult(uint32_t grfid, uint16_t cbid, uint16_t cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
Definition newgrf_commons.cpp:505
Convert8bitBooleanCallback
bool Convert8bitBooleanCallback(const GRFFile *grffile, uint16_t cbid, uint16_t cb_res)
Converts a callback result into a boolean.
Definition newgrf_commons.cpp:554
ConvertBooleanCallback
bool ConvertBooleanCallback(const GRFFile *grffile, uint16_t cbid, uint16_t cb_res)
Converts a callback result into a boolean.
Definition newgrf_commons.cpp:535
GetGRFConfig
GRFConfig * GetGRFConfig(uint32_t grfid, uint32_t mask)
Retrieve a NewGRF from the current config by its grfid.
Definition newgrf_config.cpp:696
newgrf_debug.h
Functions/types related to NewGRF debugging.
DeleteNewGRFInspectWindow
void DeleteNewGRFInspectWindow(GrfSpecFeature feature, uint index)
Delete inspect window for a given feature and index.
Definition newgrf_debug_gui.cpp:729
DecreaseBuildingCount
void DecreaseBuildingCount(Town *t, HouseID house_id)
DecreaseBuildingCount() Decrease the number of a building when it is deleted.
Definition newgrf_house.cpp:209
IncreaseBuildingCount
void IncreaseBuildingCount(Town *t, HouseID house_id)
IncreaseBuildingCount() Increase the count of a building when it has been added by a town.
Definition newgrf_house.cpp:190
InitializeBuildingCounts
void InitializeBuildingCounts()
Initialise global building counts and all town building counts.
Definition newgrf_house.cpp:163
newgrf_house.h
Functions related to NewGRF houses.
GetGRFStringID
StringID GetGRFStringID(uint32_t grfid, StringID stringid)
Returns the index for this stringid associated with its grfID.
Definition newgrf_text.cpp:587
newgrf_text.h
Header of Action 04 "universal holder" structure and functions.
news_func.h
Functions related to news.
AddNewsItem
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
@ NT_INDUSTRY_OPEN
Opening of industries.
Definition news_type.h:29
NT_GENERAL
@ NT_GENERAL
General news (from towns)
Definition news_type.h:39
NR_TOWN
@ NR_TOWN
Reference town. Scroll to town when clicking on the news.
Definition news_type.h:58
NR_NONE
@ NR_NONE
Empty reference.
Definition news_type.h:53
NF_COMPANY
@ NF_COMPANY
Company news item. (Newspaper with face)
Definition news_type.h:83
NF_NORMAL
@ NF_NORMAL
Normal news item. (Newspaper with text only)
Definition news_type.h:81
object.h
Functions related to objects.
BuildObject
void BuildObject(ObjectType type, TileIndex tile, CompanyID owner=OWNER_NONE, struct Town *town=nullptr, uint8_t view=0)
Actually build the object.
Definition object_cmd.cpp:88
object_base.h
Base for all objects.
object_map.h
Map accessors for object tiles.
OBJECT_STATUE
static const ObjectType OBJECT_STATUE
Statue in towns.
Definition object_type.h:18
pool_func.hpp
Some methods of Pool are placed here in order to reduce compilation time and binary size.
INSTANTIATE_POOL_METHODS
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
Definition pool_func.hpp:237
IsPlainRailTile
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
_random
Randomizer _random
Random used in the game state calculations.
Definition random_func.cpp:37
random_func.hpp
Pseudo random number generator.
RandomRange
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.
Definition random_func.hpp:88
Chance16
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.
Definition random_func.hpp:134
CleanUpRoadBits
RoadBits CleanUpRoadBits(const TileIndex tile, RoadBits org_rb)
Clean up unnecessary RoadBits of a planned tile.
Definition road.cpp:47
road.h
Road specific functions.
ROTF_NO_HOUSES
@ ROTF_NO_HOUSES
Bit number for setting this roadtype as not house friendly.
Definition road.h:40
ROTF_TOWN_BUILD
@ ROTF_TOWN_BUILD
Bit number for allowing towns to build this roadtype.
Definition road.h:42
GetRoadTypeInfo
const RoadTypeInfo * GetRoadTypeInfo(RoadType roadtype)
Returns a pointer to the Roadtype information for a given roadtype.
Definition road.h:227
UpdateNearestTownForRoadTiles
void UpdateNearestTownForRoadTiles(bool invalidate)
Updates cached nearest town for all road tiles.
Definition road_cmd.cpp:1918
road_cmd.h
Road related functions.
DiagDirToRoadBits
RoadBits DiagDirToRoadBits(DiagDirection d)
Create the road-part which belongs to the given DiagDirection.
Definition road_func.h:96
road_internal.h
Functions used internally by the roads.
GetAnyRoadBits
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
SetRoadOwner
void SetRoadOwner(Tile t, RoadTramType rtt, Owner o)
Set the owner of a specific road type.
Definition road_map.h:251
HasTownOwnedRoad
bool HasTownOwnedRoad(Tile t)
Checks if given tile has town owned road.
Definition road_map.h:280
IsNormalRoadTile
static debug_inline bool IsNormalRoadTile(Tile t)
Return whether a tile is a normal road tile.
Definition road_map.h:74
IsRoadDepot
static debug_inline bool IsRoadDepot(Tile t)
Return whether a tile is a road depot.
Definition road_map.h:106
GetDisallowedRoadDirections
DisallowedRoadDirections GetDisallowedRoadDirections(Tile t)
Gets the disallowed directions.
Definition road_map.h:301
HasTileRoadType
bool HasTileRoadType(Tile t, RoadTramType rtt)
Check if a tile has a road or a tram road type.
Definition road_map.h:211
GetRoadDepotDirection
DiagDirection GetRoadDepotDirection(Tile t)
Get the direction of the exit of a road depot.
Definition road_map.h:565
IsRoadDepotTile
static debug_inline bool IsRoadDepotTile(Tile t)
Return whether a tile is a road depot tile.
Definition road_map.h:116
IsRoadOwner
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
RoadBits
Enumeration for the road parts on a tile.
Definition road_type.h:52
ROAD_SW
@ ROAD_SW
South-west part.
Definition road_type.h:55
ROAD_ALL
@ ROAD_ALL
Full 4-way crossing.
Definition road_type.h:66
ROAD_NONE
@ ROAD_NONE
No road-part is build.
Definition road_type.h:53
ROAD_E
@ ROAD_E
Road at the two eastern edges.
Definition road_type.h:62
ROAD_NE
@ ROAD_NE
North-east part.
Definition road_type.h:57
ROAD_N
@ ROAD_N
Road at the two northern edges.
Definition road_type.h:61
ROAD_SE
@ ROAD_SE
South-east part.
Definition road_type.h:56
ROAD_Y
@ ROAD_Y
Full road along the y-axis (north-west + south-east)
Definition road_type.h:59
ROAD_S
@ ROAD_S
Road at the two southern edges.
Definition road_type.h:63
ROAD_W
@ ROAD_W
Road at the two western edges.
Definition road_type.h:64
ROAD_NW
@ ROAD_NW
North-west part.
Definition road_type.h:54
ROAD_X
@ ROAD_X
Full road along the x-axis (south-west + north-east)
Definition road_type.h:58
RoadType
RoadType
The different roadtypes we support.
Definition road_type.h:25
INVALID_ROADTYPE
@ INVALID_ROADTYPE
flag for invalid roadtype
Definition road_type.h:30
ROADTYPE_ROAD
@ ROADTYPE_ROAD
Basic road type.
Definition road_type.h:27
ROADTYPE_END
@ ROADTYPE_END
Used for iterations.
Definition road_type.h:29
ROADTYPE_BEGIN
@ ROADTYPE_BEGIN
Used for iterations.
Definition road_type.h:26
DRD_NONE
@ DRD_NONE
None of the directions are disallowed.
Definition road_type.h:74
safeguards.h
A number of safeguards to prevent using unsafe methods.
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:57
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:56
GetSlopeMaxZ
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
IsSlopeWithOneCornerRaised
bool IsSlopeWithOneCornerRaised(Slope s)
Tests if a specific slope has exactly one corner raised.
Definition slope_func.h:88
IsSteepSlope
static constexpr bool IsSteepSlope(Slope s)
Checks if a slope is steep.
Definition slope_func.h:36
FlatteningFoundation
Foundation FlatteningFoundation(Slope s)
Returns the foundation needed to flatten a slope.
Definition slope_func.h:369
InclinedSlope
Slope InclinedSlope(DiagDirection dir)
Returns the slope that is inclined in a specific direction.
Definition slope_func.h:256
ComplementSlope
Slope ComplementSlope(Slope s)
Return the complement of a slope.
Definition slope_func.h:76
Slope
Slope
Enumeration for the slope-type.
Definition slope_type.h:48
SLOPE_W
@ SLOPE_W
the west corner of the tile is raised
Definition slope_type.h:50
SLOPE_ELEVATED
@ SLOPE_ELEVATED
bit mask containing all 'simple' slopes
Definition slope_type.h:61
SLOPE_E
@ SLOPE_E
the east corner of the tile is raised
Definition slope_type.h:52
SLOPE_S
@ SLOPE_S
the south corner of the tile is raised
Definition slope_type.h:51
SLOPE_N
@ SLOPE_N
the north corner of the tile is raised
Definition slope_type.h:53
SLOPE_SW
@ SLOPE_SW
south and west corner are raised
Definition slope_type.h:56
SLOPE_FLAT
@ SLOPE_FLAT
a flat tile
Definition slope_type.h:49
SLOPE_STEEP_W
@ SLOPE_STEEP_W
a steep slope falling to east (from west)
Definition slope_type.h:66
SLOPE_NE
@ SLOPE_NE
north and east corner are raised
Definition slope_type.h:58
SLOPE_STEEP_E
@ SLOPE_STEEP_E
a steep slope falling to west (from east)
Definition slope_type.h:68
SLOPE_SE
@ SLOPE_SE
south and east corner are raised
Definition slope_type.h:57
SLOPE_NW
@ SLOPE_NW
north and west corner are raised
Definition slope_type.h:55
SLOPE_STEEP_N
@ SLOPE_STEEP_N
a steep slope falling to south (from north)
Definition slope_type.h:69
SLOPE_STEEP_S
@ SLOPE_STEEP_S
a steep slope falling to north (from south)
Definition slope_type.h:67
Foundation
Foundation
Enumeration for Foundations.
Definition slope_type.h:93
FOUNDATION_LEVELED
@ FOUNDATION_LEVELED
The tile is leveled up to a flat slope.
Definition slope_type.h:95
FOUNDATION_NONE
@ FOUNDATION_NONE
The tile has no foundation, the slope remains unchanged.
Definition slope_type.h:94
station_base.h
Base classes/functions for stations.
ForAllStationsAroundTiles
void ForAllStationsAroundTiles(const TileArea &ta, Func func)
Call a function on all stations that have any part of the requested area within their catchment.
Definition station_base.h:564
UpdateAllStationVirtCoords
void UpdateAllStationVirtCoords()
Update the virtual coords needed to draw the station sign for all stations.
Definition station_cmd.cpp:476
UpdateAirportsNoise
void UpdateAirportsNoise()
Recalculate the noise generated by the airports of each town.
Definition station_cmd.cpp:2502
station_kdtree.h
Declarations for accessing the k-d tree of stations.
ForAllStationsRadius
void ForAllStationsRadius(TileIndex center, uint radius, Func func)
Call a function on all stations whose sign is within a radius of a center tile.
Definition station_kdtree.h:35
IsBayRoadStopTile
bool IsBayRoadStopTile(Tile t)
Is tile t a bay (non-drive through) road stop station?
Definition station_map.h:266
IsDriveThroughStopTile
bool IsDriveThroughStopTile(Tile t)
Is tile t a drive through road stop station or waypoint?
Definition station_map.h:276
GetDriveThroughStopAxis
Axis GetDriveThroughStopAxis(Tile t)
Gets the axis of the drive through stop.
Definition station_map.h:356
GetBayRoadStopDir
DiagDirection GetBayRoadStopDir(Tile t)
Gets the direction the bay road stop entrance points towards.
Definition station_map.h:344
IsAnyRoadStopTile
bool IsAnyRoadStopTile(Tile t)
Is tile t a road stop station?
Definition station_map.h:256
FACIL_AIRPORT
@ FACIL_AIRPORT
Station with an airport.
Definition station_type.h:57
stdafx.h
Definition of base types and functions in a cross-platform compatible way.
MAX_UVALUE
#define MAX_UVALUE(type)
The largest value that can be entered in a variable.
Definition stdafx.h:343
lengthof
#define lengthof(array)
Return the length of an fixed size array.
Definition stdafx.h:280
Utf8StringLength
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
string_func.h
Functions related to low-level strings.
SetDParam
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
GetString
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
SetDParamStr
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
strings_func.h
Functions related to OTTD's strings.
StringID
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition strings_type.h:16
INVALID_STRING_ID
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition strings_type.h:17
AutoRestoreBackup
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
Definition backup_type.hpp:150
Backup
Class to backup a specific variable and restore it later.
Definition backup_type.hpp:21
Backup::Restore
void Restore()
Restore the variable.
Definition backup_type.hpp:110
BaseStation::owner
Owner owner
The owner of this station.
Definition base_station_base.h:69
CargoArray
Class for storing amounts of cargo.
Definition cargo_type.h:114
CargoPacket::InvalidateAllFrom
static void InvalidateAllFrom(SourceType src_type, SourceID src)
Invalidates (sets source_id to INVALID_SOURCE) all cargo packets from given source.
Definition cargopacket.cpp:137
CargoSpec
Specification of a cargo type.
Definition cargotype.h:76
CargoSpec::Iterate
static IterateWrapper Iterate(size_t from=0)
Returns an iterable ensemble of all valid CargoSpec.
Definition cargotype.h:195
CargoSpec::town_production_cargoes
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
Cheat::value
bool value
tells if the bool cheat is active or not
Definition cheat_type.h:18
Cheats::magic_bulldozer
Cheat magic_bulldozer
dynamite industries, objects
Definition cheat_type.h:27
ClientSettings::gui
GUISettings gui
settings related to the GUI
Definition settings_type.h:610
CommandHelper
Definition command_func.h:83
Company
Definition company_base.h:133
ConstructionSettings::build_on_slopes
bool build_on_slopes
allow building on slopes
Definition settings_type.h:383
Depot
Definition depot_base.h:20
DifficultySettings::number_towns
uint8_t number_towns
the amount of towns
Definition settings_type.h:101
DifficultySettings::town_council_tolerance
uint8_t town_council_tolerance
minimum required town ratings to be allowed to demolish stuff
Definition settings_type.h:116
DrawBuildingsTileStruct
This structure is the same for both Industries and Houses.
Definition sprite.h:67
EconomySettings::bribe
bool bribe
enable bribing the local authority
Definition settings_type.h:515
EconomySettings::found_town
TownFounding found_town
town founding.
Definition settings_type.h:531
EconomySettings::exclusive_rights
bool exclusive_rights
allow buying exclusive rights
Definition settings_type.h:519
EconomySettings::initial_city_size
uint8_t initial_city_size
multiplier for the initial size of the cities compared to towns
Definition settings_type.h:527
EconomySettings::town_layout
TownLayout town_layout
select town layout,
Definition settings_type.h:528
EconomySettings::allow_town_level_crossings
bool allow_town_level_crossings
towns are allowed to build level crossings
Definition settings_type.h:534
EconomySettings::town_growth_rate
uint8_t town_growth_rate
town growth rate
Definition settings_type.h:525
EconomySettings::allow_town_roads
bool allow_town_roads
towns are allowed to build roads (always allowed when generating world / in SE)
Definition settings_type.h:530
EconomySettings::fund_buildings
bool fund_buildings
allow funding new buildings
Definition settings_type.h:520
EconomySettings::fund_roads
bool fund_roads
allow funding local road reconstruction
Definition settings_type.h:521
EconomySettings::town_cargogen_mode
TownCargoGenMode town_cargogen_mode
algorithm for generating cargo from houses,
Definition settings_type.h:529
EconomySettings::dist_local_authority
uint8_t dist_local_authority
distance for town local authority, default 20
Definition settings_type.h:518
EconomySettings::larger_towns
uint8_t larger_towns
the number of cities to build. These start off larger and grow twice as fast
Definition settings_type.h:526
GRFConfig
Information about GRF, used in the game and (part of it) in savegames.
Definition newgrf_config.h:154
GRFConfig::GetName
const char * GetName() const
Get the name of this grf.
Definition newgrf_config.cpp:92
GRFFilePropsBase::HasGrfFile
bool HasGrfFile() const
Test if this entity was introduced by NewGRF.
Definition newgrf_commons.h:320
GRFFilePropsBase::grfid
uint32_t grfid
grfid that introduced this entity.
Definition newgrf_commons.h:312
GRFFilePropsBase::grffile
const struct GRFFile * grffile
grf file that introduced this entity
Definition newgrf_commons.h:313
GRFFilePropsBase::spritegroup
std::array< const struct SpriteGroup *, Tcnt > spritegroup
pointers to the different sprites of the entity
Definition newgrf_commons.h:314
GRFFileProps::override
uint16_t override
id of the entity been replaced by
Definition newgrf_commons.h:329
GUISettings::population_in_label
bool population_in_label
show the population of a town in its label?
Definition settings_type.h:175
GameCreationSettings::custom_town_number
uint16_t custom_town_number
manually entered number of towns
Definition settings_type.h:370
GameCreationSettings::landscape
uint8_t landscape
the landscape we're currently in
Definition settings_type.h:368
GameCreationSettings::town_name
uint8_t town_name
the town name generator used for town names
Definition settings_type.h:367
GameSettings::economy
EconomySettings economy
settings to change the economy
Definition settings_type.h:602
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition settings_type.h:594
GameSettings::difficulty
DifficultySettings difficulty
settings related to the difficulty
Definition settings_type.h:592
GameSettings::game_creation
GameCreationSettings game_creation
settings used during the creation of a game (map)
Definition settings_type.h:593
GoodsEntry
Stores station stats for a single cargo.
Definition station_base.h:166
HouseSpec
Definition house.h:93
HouseSpec::probability
uint8_t probability
Relative probability of appearing (16 is the standard value)
Definition house.h:112
HouseSpec::accepts_cargo
CargoID accepts_cargo[HOUSE_NUM_ACCEPTS]
input cargo slots
Definition house.h:103
HouseSpec::removal_cost
uint8_t removal_cost
cost multiplier for removing it
Definition house.h:98
HouseSpec::mail_generation
uint8_t mail_generation
mail generation multiplier (tile based, as the acceptances below)
Definition house.h:101
HouseSpec::enabled
bool enabled
the house is available to build (true by default, but can be disabled by newgrf)
Definition house.h:106
HouseSpec::GetRemovalCost
Money GetRemovalCost() const
Get the cost for removing this house.
Definition town_cmd.cpp:225
HouseSpec::Get
static HouseSpec * Get(size_t house_id)
Get the spec for a house ID.
Definition newgrf_house.cpp:69
HouseSpec::building_flags
BuildingFlags building_flags
some flags that describe the house (size, stadium etc...)
Definition house.h:104
HouseSpec::max_year
TimerGameCalendar::Year max_year
last year it can be built
Definition house.h:96
HouseSpec::remove_rating_decrease
uint16_t remove_rating_decrease
rating decrease if removed
Definition house.h:100
HouseSpec::population
uint8_t population
population (Zero on other tiles in multi tile house.)
Definition house.h:97
HouseSpec::extra_flags
HouseExtraFlags extra_flags
some more flags
Definition house.h:113
HouseSpec::cargo_acceptance
uint8_t cargo_acceptance[HOUSE_NUM_ACCEPTS]
acceptance level for the cargo slots
Definition house.h:102
HouseSpec::Index
HouseID Index() const
Gets the index of this spec.
Definition newgrf_house.cpp:59
HouseSpec::class_id
HouseClassID class_id
defines the class this house has (not grf file based)
Definition house.h:114
HouseSpec::building_name
StringID building_name
building name
Definition house.h:99
HouseSpec::minimum_life
uint8_t minimum_life
The minimum number of years this house will survive before the town rebuilds it.
Definition house.h:117
HouseSpec::grf_prop
GRFFileProps grf_prop
Properties related the the grf file.
Definition house.h:109
HouseSpec::callback_mask
uint16_t callback_mask
Bitmask of house callbacks that have to be called.
Definition house.h:110
HouseSpec::building_availability
HouseZones building_availability
where can it be built (climates, zones)
Definition house.h:105
HouseSpec::Specs
static std::vector< HouseSpec > & Specs()
Get a reference to all HouseSpecs.
Definition newgrf_house.cpp:50
Industry
Defines the internal data of a functional industry.
Definition industry.h:66
Industry::town
Town * town
Nearest town.
Definition industry.h:95
Industry::GetByTile
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition industry.h:238
Map
Size related data of the map.
Definition map_func.h:206
Map::ScaleBySize
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
Map::Iterate
static IterateWrapper Iterate()
Returns an iterable ensemble of all Tiles.
Definition map_func.h:363
Map::Size
static debug_inline uint Size()
Get the size of the map.
Definition map_func.h:288
Object
An object, such as transmitter, on the map.
Definition object_base.h:23
Object::type
ObjectType type
Type of the object.
Definition object_base.h:24
Object::town
Town * town
Town the object is built in.
Definition object_base.h:25
Object::GetByTile
static Object * GetByTile(TileIndex tile)
Get the object associated with a tile.
Definition object_cmd.cpp:55
OrthogonalTileArea
Represents the covered area of e.g.
Definition tilearea_type.h:18
OrthogonalTileArea::Add
void Add(TileIndex to_add)
Add a single tile to a tile area; enlarge if needed.
Definition tilearea.cpp:43
PalSpriteID::sprite
SpriteID sprite
The 'real' sprite.
Definition gfx_type.h:24
PalSpriteID::pal
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition gfx_type.h:25
Point
Coordinates of a point in 2D.
Definition geometry_type.hpp:21
Pool::PoolItem<&_town_pool >::GetPoolSize
static size_t GetPoolSize()
Returns first unused index.
Definition pool_type.hpp:360
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition pool_type.hpp:238
Pool::PoolItem<&_town_pool >::GetNumItems
static size_t GetNumItems()
Returns number of valid items in the pool.
Definition pool_type.hpp:369
Pool::PoolItem<&_town_pool >::CleaningPool
static bool CleaningPool()
Returns current state of pool cleaning - yes or no.
Definition pool_type.hpp:318
Pool::PoolItem<&_town_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition pool_type.hpp:328
Pool::PoolItem<&_industry_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition pool_type.hpp:388
Pool::PoolItem<&_town_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition pool_type.hpp:350
Pool::PoolItem<&_town_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition pool_type.hpp:309
Pool::PoolItem<&_town_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition pool_type.hpp:339
Pool
Base class for all pools.
Definition pool_type.hpp:80
Pool::MAX_SIZE
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
Definition pool_type.hpp:84
SpecializedStation< Station, false >::Iterate
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
Definition base_station_base.h:305
SpotData
Used as the user_data for FindFurthestFromWater.
Definition town_cmd.cpp:2279
SpotData::max_dist
uint max_dist
holds the distance that tile is from the water
Definition town_cmd.cpp:2281
SpotData::layout
TownLayout layout
tells us what kind of town we're building
Definition town_cmd.cpp:2282
SpotData::tile
TileIndex tile
holds the tile that was found
Definition town_cmd.cpp:2280
Station
Station data structure.
Definition station_base.h:439
Station::CatchmentCoversTown
bool CatchmentCoversTown(TownID t) const
Test if the given town ID is covered by our catchment area.
Definition station.cpp:448
StatueBuildSearchData
Structure for storing data while searching the best place to build a statue.
Definition town_cmd.cpp:3403
StatueBuildSearchData::tile_count
int tile_count
Number of tiles tried.
Definition town_cmd.cpp:3405
StatueBuildSearchData::best_position
TileIndex best_position
Best position found so far.
Definition town_cmd.cpp:3404
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
TileDesc
Tile description for the 'land area information' tool.
Definition tile_cmd.h:52
TileDesc::str
StringID str
Description of the tile.
Definition tile_cmd.h:53
TileDesc::dparam
uint64_t dparam
Parameter of the str string.
Definition tile_cmd.h:54
TileDesc::grf
const char * grf
newGRF used for the tile contents
Definition tile_cmd.h:63
TileDesc::owner
Owner owner[4]
Name of the owner(s)
Definition tile_cmd.h:55
TileIndexDiffC
A pair-construct of a TileIndexDiff.
Definition map_type.h:31
TileIndexDiffC::x
int16_t x
The x value of the coordinate.
Definition map_type.h:32
TileIndexDiffC::y
int16_t y
The y value of the coordinate.
Definition map_type.h:33
TileInfo
Tile information, used while rendering the tile.
Definition tile_cmd.h:43
TileInfo::z
int z
Height.
Definition tile_cmd.h:48
TileInfo::x
int x
X position of the tile in unit coordinates.
Definition tile_cmd.h:44
TileInfo::tileh
Slope tileh
Slope of the tile.
Definition tile_cmd.h:46
TileInfo::tile
TileIndex tile
Tile index.
Definition tile_cmd.h:47
TileInfo::y
int y
Y position of the tile in unit coordinates.
Definition tile_cmd.h:45
TileTypeProcs
Set of callback functions for performing tile operations of a given tile type.
Definition tile_cmd.h:158
TownCache::population
uint32_t population
Current population of people.
Definition town.h:44
TownCache::num_houses
uint32_t num_houses
Amount of houses.
Definition town.h:43
TownCache::squared_town_zone_radius
std::array< uint32_t, HZB_END > squared_town_zone_radius
UpdateTownRadius updates this given the house count.
Definition town.h:47
TownCache::sign
TrackedViewportSign sign
Location of name sign, UpdateVirtCoord updates this.
Definition town.h:45
TownCache::building_counts
BuildingCounts< uint16_t > building_counts
The number of each type of building in the town.
Definition town.h:48
TownNameParams
Struct holding parameters used to generate town name.
Definition townname_type.h:28
TownNameParams::type
uint16_t type
town name style
Definition townname_type.h:30
TownNameParams::grfid
uint32_t grfid
newgrf ID (0 if not used)
Definition townname_type.h:29
Town
Town data structure.
Definition town.h:54
Town::larger_town
bool larger_town
if this is a larger town and should grow more quickly
Definition town.h:101
Town::supplied
TransportedCargoStat< uint32_t > supplied[NUM_CARGO]
Cargo statistics about supplied cargo.
Definition town.h:79
Town::statues
CompanyMask statues
which companies have a statue?
Definition town.h:70
Town::time_until_rebuild
uint16_t time_until_rebuild
time until we rebuild a house
Definition town.h:93
Town::cached_name
std::string cached_name
NOSAVE: Cache of the resolved name of the town, if not using a custom town name.
Definition town.h:64
Town::xy
TileIndex xy
town center tile
Definition town.h:55
Town::fund_buildings_months
uint8_t fund_buildings_months
fund buildings program in action?
Definition town.h:98
Town::ratings
int16_t ratings[MAX_COMPANIES]
ratings of each company for this town
Definition town.h:77
Town::layout
TownLayout layout
town specific road layout
Definition town.h:102
Town::received
TransportedCargoStat< uint16_t > received[NUM_TAE]
Cargo statistics about received cargotypes.
Definition town.h:80
Town::GetRandom
static Town * GetRandom()
Return a random valid town.
Definition town_cmd.cpp:196
Town::name
std::string name
Custom town name. If empty, the town was not renamed and uses the generated name.
Definition town.h:63
Town::grow_counter
uint16_t grow_counter
counter to count when to grow, value is smaller than or equal to growth_rate
Definition town.h:95
Town::flags
uint8_t flags
See TownFlags.
Definition town.h:66
Town::cache
TownCache cache
Container for all cacheable data.
Definition town.h:57
Town::exclusivity
CompanyID exclusivity
which company has exclusivity
Definition town.h:75
Town::InitializeLayout
void InitializeLayout(TownLayout layout)
Assign the town layout.
Definition town_cmd.cpp:182
Town::show_zone
bool show_zone
NOSAVE: mark town to show the local authority zone in the viewports.
Definition town.h:104
Town::goal
uint32_t goal[NUM_TAE]
Amount of cargo required for the town to grow.
Definition town.h:81
Town::exclusive_counter
uint8_t exclusive_counter
months till the exclusivity expires
Definition town.h:76
Town::UpdateVirtCoord
void UpdateVirtCoord()
Resize the sign (label) of the town after it changes population.
Definition town_cmd.cpp:409
Town::text
std::string text
General text with additional information.
Definition town.h:83
Town::have_ratings
CompanyMask have_ratings
which companies have a rating
Definition town.h:73
Town::~Town
~Town()
Destroy the town.
Definition town_cmd.cpp:110
Town::unwanted
uint8_t unwanted[MAX_COMPANIES]
how many months companies aren't wanted by towns (bribe)
Definition town.h:74
Town::growth_rate
uint16_t growth_rate
town growth rate
Definition town.h:96
Town::stations_near
StationList stations_near
NOSAVE: List of nearby stations.
Definition town.h:91
Town::PostDestructor
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
Town::road_build_months
uint8_t road_build_months
fund road reconstruction in action?
Definition town.h:99
TrackedViewportSign::UpdatePosition
void UpdatePosition(int center, int top, StringID str, StringID str_small=STR_NULL)
Update the position of the viewport sign.
Definition viewport_type.h:60
TrackedViewportSign::kdtree_valid
bool kdtree_valid
Are the sign data valid for use with the _viewport_sign_kdtree?
Definition viewport_type.h:52
TransportedCargoStat::new_max
Tstorage new_max
Maximum amount this month.
Definition town_type.h:115
TransportedCargoStat::old_max
Tstorage old_max
Maximum amount last month.
Definition town_type.h:114
TransportedCargoStat::old_act
Tstorage old_act
Actually transported last month.
Definition town_type.h:116
TransportedCargoStat::new_act
Tstorage new_act
Actually transported this month.
Definition town_type.h:117
Waypoint
Representation of a waypoint.
Definition waypoint_base.h:23
DeleteSubsidyWith
void DeleteSubsidyWith(SourceType type, SourceID index)
Delete the subsidies associated with a given cargo source type and id.
Definition subsidy.cpp:151
subsidy_func.h
Functions related to subsidies.
terraform_cmd.h
Command definitions related to terraforming.
IsTileFlat
bool IsTileFlat(TileIndex tile, int *h)
Check if a given tile is flat.
Definition tile_map.cpp:95
GetTileMaxZ
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
Definition tile_map.cpp:136
GetTileZ
int GetTileZ(TileIndex tile)
Get bottom height of the tile.
Definition tile_map.cpp:116
TileHash
uint TileHash(uint x, uint y)
Calculate a hash value from a tile position.
Definition tile_map.h:324
IsTileOwner
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition tile_map.h:214
GetTileMaxPixelZ
int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
Definition tile_map.h:312
GetTileType
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition tile_map.h:96
IsValidTile
bool IsValidTile(Tile tile)
Checks if a tile is valid.
Definition tile_map.h:161
TileHash2Bit
uint TileHash2Bit(uint x, uint y)
Get the last two bits of the TileHash from a tile position.
Definition tile_map.h:342
GetTropicZone
TropicZone GetTropicZone(Tile tile)
Get the tropic zone.
Definition tile_map.h:238
IsTileType
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
GetTileSlope
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
Definition tile_map.h:279
TileHeight
static debug_inline uint TileHeight(Tile tile)
Returns the height of a tile.
Definition tile_map.h:29
TROPICZONE_DESERT
@ TROPICZONE_DESERT
Tile is desert.
Definition tile_type.h:78
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
INVALID_TILE
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:95
MP_TREES
@ MP_TREES
Tile got trees.
Definition tile_type.h:52
MP_ROAD
@ MP_ROAD
A tile with road (or tram tracks)
Definition tile_type.h:50
MP_STATION
@ MP_STATION
A tile of a station.
Definition tile_type.h:53
MP_TUNNELBRIDGE
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
Definition tile_type.h:57
MP_CLEAR
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
Definition tile_type.h:48
MP_HOUSE
@ MP_HOUSE
A house by a town.
Definition tile_type.h:51
MP_WATER
@ MP_WATER
Water tile.
Definition tile_type.h:54
MP_RAILWAY
@ MP_RAILWAY
A railway.
Definition tile_type.h:49
MP_INDUSTRY
@ MP_INDUSTRY
Part of an industry.
Definition tile_type.h:56
MP_VOID
@ MP_VOID
Invisible tiles at the SW and SE border.
Definition tile_type.h:55
MP_OBJECT
@ MP_OBJECT
Contains objects such as transmitters and owned land.
Definition tile_type.h:58
TileArea
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
Definition tilearea_type.h:102
timer.h
Definition of Interval and OneShot timers.
timer_game_calendar.h
Definition of the game-calendar-timer.
timer_game_economy.h
Definition of the game-economy-timer.
timer_game_tick.h
Definition of the tick-based game-timer.
town.h
Base of the town class.
TOWN_GROWTH_WINTER
static const uint TOWN_GROWTH_WINTER
The town only needs this cargo in the winter (any amount)
Definition town.h:33
TOWN_GROWTH_DESERT
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
@ TOWN_HAS_CHURCH
There can be only one church by town.
Definition town.h:197
TOWN_HAS_STADIUM
@ TOWN_HAS_STADIUM
There can be only one stadium by town.
Definition town.h:198
TOWN_IS_GROWING
@ TOWN_IS_GROWING
Conditions for town growth are met. Grow according to Town::growth_rate.
Definition town.h:196
TOWN_CUSTOM_GROWTH
@ TOWN_CUSTOM_GROWTH
Growth rate is controlled by GS.
Definition town.h:199
TownRatingCheckType
TownRatingCheckType
Action types that a company must ask permission for to a town authority.
Definition town.h:175
TOWN_RATING_CHECK_TYPE_COUNT
@ TOWN_RATING_CHECK_TYPE_COUNT
Number of town checking action types.
Definition town.h:178
TownActions
TownActions
Town actions of a company.
Definition town.h:212
TACT_BUILD_STATUE
@ TACT_BUILD_STATUE
Build a statue.
Definition town.h:219
TACT_ROAD_REBUILD
@ TACT_ROAD_REBUILD
Rebuild the roads.
Definition town.h:218
TACT_BUY_RIGHTS
@ TACT_BUY_RIGHTS
Buy exclusive transport rights.
Definition town.h:221
TACT_BRIBE
@ TACT_BRIBE
Try to bribe the council.
Definition town.h:222
TACT_COUNT
@ TACT_COUNT
Number of available town actions.
Definition town.h:224
TACT_FUND_BUILDINGS
@ TACT_FUND_BUILDINGS
Fund new buildings.
Definition town.h:220
TACT_NONE
@ TACT_NONE
Empty action set.
Definition town.h:213
CUSTOM_TOWN_NUMBER_DIFFICULTY
static const uint CUSTOM_TOWN_NUMBER_DIFFICULTY
value for custom town number in difficulty settings
Definition town.h:28
CalcClosestTownFromTile
Town * CalcClosestTownFromTile(TileIndex tile, uint threshold=UINT_MAX)
Return the town closest to the given tile within threshold.
Definition town_cmd.cpp:3878
TOWN_GROWTH_RATE_NONE
static const uint16_t TOWN_GROWTH_RATE_NONE
Special value for Town::growth_rate to disable town growth.
Definition town.h:35
RoadTypesAllowHouseHere
static bool RoadTypesAllowHouseHere(TileIndex t)
Checks whether at least one surrounding road allows to build a house here.
Definition town_cmd.cpp:1478
CmdFoundTown
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.
Definition town_cmd.cpp:2142
CheckFree2x2Area
static bool CheckFree2x2Area(TileIndex tile, int z, bool noslope)
Checks if a house of size 2x2 can be built at this tile.
Definition town_cmd.cpp:2587
TownLayoutAllows2x2HouseHere
static bool TownLayoutAllows2x2HouseHere(Town *t, TileIndex tile)
Checks if the current town layout allows a 2x2 building here.
Definition town_cmd.cpp:2639
ClearMakeHouseTile
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.
Definition town_cmd.cpp:2498
GetTownRadiusGroup
HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile)
Returns the bit corresponding to the town zone of the specified tile.
Definition town_cmd.cpp:2474
GrowTownWithExtraHouse
static bool GrowTownWithExtraHouse(Town *t, TileIndex tile)
Grows the town with an extra house.
Definition town_cmd.cpp:1203
SearchTileForStatue
static bool SearchTileForStatue(TileIndex tile, void *user_data)
Search callback function for TownActionBuildStatue.
Definition town_cmd.cpp:3416
FindNearestEmptyLand
static bool FindNearestEmptyLand(TileIndex tile, void *)
CircularTileSearch callback to find the nearest land tile.
Definition town_cmd.cpp:2321
IsTileAlignedToGrid
static bool IsTileAlignedToGrid(TileIndex tile, TownLayout layout)
Towns must all be placed on the same grid or when they eventually interpenetrate their road networks ...
Definition town_cmd.cpp:2267
AddAcceptedCargoSetMask
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
TownActionBribe
static CommandCost TownActionBribe(Town *t, DoCommandFlag flags)
Perform the "bribe" town action.
Definition town_cmd.cpp:3550
CmdRenameTown
CommandCost CmdRenameTown(DoCommandFlag flags, TownID town_id, const std::string &text)
Rename a town (server-only).
Definition town_cmd.cpp:3018
GetHouseNorthPart
TileIndexDiff GetHouseNorthPart(HouseID &house)
Determines if a given HouseID is part of a multitile house.
Definition town_cmd.cpp:2950
TownActionAdvertiseLarge
static CommandCost TownActionAdvertiseLarge(Town *t, DoCommandFlag flags)
Perform the "large advertising campaign" town action.
Definition town_cmd.cpp:3352
TownActionAdvertiseSmall
static CommandCost TownActionAdvertiseSmall(Town *t, DoCommandFlag flags)
Perform the "small advertising campaign" town action.
Definition town_cmd.cpp:3324
GetRating
static int GetRating(const Town *t)
Get the rating of a town for the _current_company.
Definition town_cmd.cpp:3957
ClearTownHouse
void ClearTownHouse(Town *t, TileIndex tile)
Clear a town house.
Definition town_cmd.cpp:2975
GetNormalGrowthRate
static uint GetNormalGrowthRate(Town *t)
Calculates town growth rate in normal conditions (custom growth rate not set).
Definition town_cmd.cpp:3770
GetMaskOfTownActions
TownActions GetMaskOfTownActions(CompanyID cid, const Town *t)
Get a list of available town authority actions.
Definition town_cmd.cpp:3605
ClearTile_Town
static CommandCost ClearTile_Town(TileIndex tile, DoCommandFlag flags)
Callback function to clear a house tile.
Definition town_cmd.cpp:717
GrowTownWithBridge
static bool GrowTownWithBridge(const Town *t, const TileIndex tile, const DiagDirection bridge_dir)
Grows the town with a bridge.
Definition town_cmd.cpp:1331
FindFirstCargoWithTownAcceptanceEffect
const CargoSpec * FindFirstCargoWithTownAcceptanceEffect(TownAcceptanceEffect effect)
Determines the first cargo with a certain town effect.
Definition town_cmd.cpp:3052
FindNearestGoodCoastalTownSpot
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.
Definition town_cmd.cpp:2338
CmdTownGrowthRate
CommandCost CmdTownGrowthRate(DoCommandFlag flags, TownID town_id, uint16_t growth_rate)
Change the growth rate of the town.
Definition town_cmd.cpp:3119
ClosestTownFromTile
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
Definition town_cmd.cpp:3896
IsRoadAllowedHere
static bool IsRoadAllowedHere(Town *t, TileIndex tile, DiagDirection dir)
Check if a Road is allowed on a given tile.
Definition town_cmd.cpp:1067
CanRoadContinueIntoNextTile
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.
Definition town_cmd.cpp:1264
CmdTownRating
CommandCost CmdTownRating(DoCommandFlag flags, TownID town_id, CompanyID company_id, int16_t rating)
Change the rating of a company in a town.
Definition town_cmd.cpp:3157
UpdateTownGrowCounter
static void UpdateTownGrowCounter(Town *t, uint16_t prev_growth_rate)
Updates town grow counter after growth rate change.
Definition town_cmd.cpp:3738
CmdTownCargoGoal
CommandCost CmdTownCargoGoal(DoCommandFlag flags, TownID town_id, TownAcceptanceEffect tae, uint32_t goal)
Change the cargo goal of a town.
Definition town_cmd.cpp:3068
CountActiveStations
static int CountActiveStations(Town *t)
Calculates amount of active stations in the range of town (HZB_TOWN_EDGE).
Definition town_cmd.cpp:3753
TownCanBePlacedHere
static CommandCost TownCanBePlacedHere(TileIndex tile)
Check if it's possible to place a town on a given tile.
Definition town_cmd.cpp:2096
_generating_town
static bool _generating_town
Set if a town is being generated.
Definition town_cmd.cpp:83
CanFollowRoad
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.
Definition town_cmd.cpp:1749
RedundantBridgeExistsNearby
static bool RedundantBridgeExistsNearby(TileIndex tile, void *user_data)
CircularTileSearch proc which checks for a nearby parallel bridge to avoid building redundant bridges...
Definition town_cmd.cpp:1306
TownLayoutAllowsHouseHere
static bool TownLayoutAllowsHouseHere(Town *t, TileIndex tile)
Checks if the current town layout allows building here.
Definition town_cmd.cpp:2608
TileLoop_Town
static void TileLoop_Town(TileIndex tile)
Tile callback function.
Definition town_cmd.cpp:605
CanBuildHouseHere
static bool CanBuildHouseHere(TileIndex tile, bool noslope)
Check if a house can be built here, based on slope, whether there's a bridge above,...
Definition town_cmd.cpp:2543
TownActionAdvertiseMedium
static CommandCost TownActionAdvertiseMedium(Town *t, DoCommandFlag flags)
Perform the "medium advertising campaign" town action.
Definition town_cmd.cpp:3338
GrowTownWithRoad
static bool GrowTownWithRoad(const Town *t, TileIndex tile, RoadBits rcmd)
Grows the town with a road piece.
Definition town_cmd.cpp:1245
CmdDeleteTown
CommandCost CmdDeleteTown(DoCommandFlag flags, TownID town_id)
Delete a town (scenario editor or worldgen only).
Definition town_cmd.cpp:3219
UpdateTownRating
static void UpdateTownRating(Town *t)
Monthly callback to update town and station ratings.
Definition town_cmd.cpp:3700
AdvanceHouseConstruction
static void AdvanceHouseConstruction(TileIndex tile)
Increase the construction stage of a house.
Definition town_cmd.cpp:521
TownCanGrowRoad
static bool TownCanGrowRoad(TileIndex tile)
Test if town can grow road onto a specific tile.
Definition town_cmd.cpp:1506
GetWorldPopulation
uint32_t GetWorldPopulation()
Get the total population, the sum of all towns in the world.
Definition town_cmd.cpp:462
GrowTownWithTunnel
static bool GrowTownWithTunnel(const Town *t, const TileIndex tile, const DiagDirection tunnel_dir)
Grows the town with a tunnel.
Definition town_cmd.cpp:1412
_town_test_ratings
static std::map< const Town *, int > _town_test_ratings
Map of towns to modified ratings, while in town rating test-mode.
Definition town_cmd.cpp:3930
CheckClearTile
static bool CheckClearTile(TileIndex tile)
Check whether the land can be cleared.
Definition town_cmd.cpp:3394
_town_action_costs
const uint8_t _town_action_costs[TACT_COUNT]
Factor in the cost of each town action.
Definition town_cmd.cpp:3314
TownActionRoadRebuild
static CommandCost TownActionRoadRebuild(Town *t, DoCommandFlag flags)
Perform the "local road reconstruction" town action.
Definition town_cmd.cpp:3366
TownActionFundBuildings
static CommandCost TownActionFundBuildings(Town *t, DoCommandFlag flags)
Perform the "fund new buildings" town action.
Definition town_cmd.cpp:3484
TownGenerateCargoOriginal
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
UpdateTownMaxPass
void UpdateTownMaxPass(Town *t)
Update the maximum amount of montly passengers and mail for a town, based on its population.
Definition town_cmd.cpp:1993
ChangePopulation
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
CheckTownBuild2x2House
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.
Definition town_cmd.cpp:2701
GetAcceptedCargoOfHouse
CargoArray GetAcceptedCargoOfHouse(const HouseSpec *hs)
Get accepted cargo of a house prototype.
Definition town_cmd.cpp:853
TownAllowedToBuildRoads
static bool TownAllowedToBuildRoads()
Check if the town is allowed to build roads.
Definition town_cmd.cpp:1519
IsNeighborRoadTile
static bool IsNeighborRoadTile(TileIndex tile, const DiagDirection dir, uint dist_multi)
Check for parallel road inside a given distance.
Definition town_cmd.cpp:1033
GrowTown
static bool GrowTown(Town *t)
Grow the town.
Definition town_cmd.cpp:1887
RandomDiagDir
static DiagDirection RandomDiagDir()
Return a random direction.
Definition town_cmd.cpp:258
AlignTileToGrid
static TileIndex AlignTileToGrid(TileIndex tile, TownLayout layout)
Towns must all be placed on the same grid or when they eventually interpenetrate their road networks ...
Definition town_cmd.cpp:2249
CreateRandomTown
static Town * CreateRandomTown(uint attempts, uint32_t townnameparts, TownSize size, bool city, TownLayout layout)
Create a random town somewhere in the world.
Definition town_cmd.cpp:2361
RemoveNearbyStations
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
GrowTownAtRoad
static bool GrowTownAtRoad(Town *t, TileIndex tile)
Try to grow a town at a given road tile.
Definition town_cmd.cpp:1791
CalcClosestTownFromTile
Town * CalcClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest to the given tile within threshold.
Definition town_cmd.cpp:3878
ClearAllTownCachedNames
void ClearAllTownCachedNames()
Clear the cached_name of all towns.
Definition town_cmd.cpp:435
ChangeTownRating
void ChangeTownRating(Town *t, int add, int max, DoCommandFlag flags)
Changes town rating of the current company.
Definition town_cmd.cpp:3975
FindFurthestFromWater
static bool FindFurthestFromWater(TileIndex tile, void *user_data)
CircularTileSearch callback; finds the tile furthest from any water.
Definition town_cmd.cpp:2301
GetFoundation_Town
static Foundation GetFoundation_Town(TileIndex tile, Slope tileh)
Get the foundation for a house.
Definition town_cmd.cpp:326
TownGenerateCargo
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
GetTownRoadTypeFirstIntroductionDate
static TimerGameCalendar::Date GetTownRoadTypeFirstIntroductionDate()
Get the calendar date of the earliest town-buildable road type.
Definition town_cmd.cpp:988
AnimateTile_Town
static void AnimateTile_Town(TileIndex tile)
Animate a tile for a town.
Definition town_cmd.cpp:350
CmdDoTownAction
CommandCost CmdDoTownAction(DoCommandFlag flags, TownID town_id, uint8_t action)
Do a town action.
Definition town_cmd.cpp:3662
_tile_type_town_procs
const TileTypeProcs _tile_type_town_procs
Tile callback functions for a town.
Definition landscape.cpp:51
GetTownRoadType
RoadType GetTownRoadType()
Get the road type that towns should build at this current moment.
Definition town_cmd.cpp:953
GetTownRoadBits
static RoadBits GetTownRoadBits(TileIndex tile)
Return the RoadBits of a tile, ignoring depot and bay road stops.
Definition town_cmd.cpp:942
CmdExpandTown
CommandCost CmdExpandTown(DoCommandFlag flags, TownID town_id, uint32_t grow_amount)
Expand a town (scenario editor only).
Definition town_cmd.cpp:3182
TownActionBuyRights
static CommandCost TownActionBuyRights(Town *t, DoCommandFlag flags)
Perform the "buy exclusive transport rights" town action.
Definition town_cmd.cpp:3517
DoCreateTown
static void DoCreateTown(Town *t, TileIndex tile, uint32_t townnameparts, TownSize size, bool city, TownLayout layout, bool manual)
Actually create a town.
Definition town_cmd.cpp:2017
TryBuildTownHouse
static bool TryBuildTownHouse(Town *t, TileIndex tile)
Tries to build a house at this tile.
Definition town_cmd.cpp:2757
TestTownOwnsBridge
static bool TestTownOwnsBridge(TileIndex tile, const Town *t)
Check if a town 'owns' a bridge.
Definition town_cmd.cpp:94
OnTick_Town
void OnTick_Town()
Iterate through all towns and call their tick handler.
Definition town_cmd.cpp:928
CheckTownRoadTypes
bool CheckTownRoadTypes()
Check if towns are able to build road.
Definition town_cmd.cpp:1009
GenerateTowns
bool GenerateTowns(TownLayout layout)
Generate a number of towns with a given layout.
Definition town_cmd.cpp:2413
CheckIfAuthorityAllowsNewStation
CommandCost CheckIfAuthorityAllowsNewStation(TileIndex tile, DoCommandFlag flags)
Checks whether the local authority allows construction of a new station (rail, road,...
Definition town_cmd.cpp:3854
CheckforTownRating
CommandCost CheckforTownRating(DoCommandFlag flags, Town *t, TownRatingCheckType type)
Does the town authority allow the (destructive) action of the current company?
Definition town_cmd.cpp:4012
CheckTownBuild2House
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.
Definition town_cmd.cpp:2676
UpdateTownGrowthRate
static void UpdateTownGrowthRate(Town *t)
Updates town growth rate.
Definition town_cmd.cpp:3797
GetTownRoadGridElement
static RoadBits GetTownRoadGridElement(Town *t, TileIndex tile, DiagDirection dir)
Generate the RoadBits of a grid tile.
Definition town_cmd.cpp:1144
AdvanceSingleHouseConstruction
static void AdvanceSingleHouseConstruction(TileIndex tile)
Helper function for house construction stage progression.
Definition town_cmd.cpp:498
TownTickHandler
static void TownTickHandler(Town *t)
Handle the town tick for a single town, by growing the town if desired.
Definition town_cmd.cpp:911
MakeTownHouse
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.
Definition town_cmd.cpp:2521
SetTownRatingTestMode
void SetTownRatingTestMode(bool mode)
Switch the town rating to test-mode, to allow commands to be tested without affecting current ratings...
Definition town_cmd.cpp:3937
TownActionBuildStatue
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...
Definition town_cmd.cpp:3459
_town_rating_test
static bool _town_rating_test
If true, town rating is in test-mode.
Definition town_cmd.cpp:3929
UpdateTownRadius
void UpdateTownRadius(Town *t)
Update the cached town zone radii of a town, based on the number of houses.
Definition town_cmd.cpp:1946
BuildTownHouse
static void BuildTownHouse(Town *t, TileIndex tile, const HouseSpec *hs, HouseID house, uint8_t random_bits)
Build a house at this tile.
Definition town_cmd.cpp:2725
AddAcceptedCargoOfHouse
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
CmdTownSetText
CommandCost CmdTownSetText(DoCommandFlag flags, TownID town_id, const std::string &text)
Set a custom text in the Town window.
Definition town_cmd.cpp:3097
IsCloseToTown
static bool IsCloseToTown(TileIndex tile, uint dist)
Determines if a town is close to a tile.
Definition town_cmd.cpp:401
UpdateTownGrowth
static void UpdateTownGrowth(Town *t)
Updates town growth state (whether it is growing or not).
Definition town_cmd.cpp:3810
DoClearTownHouseHelper
static void DoClearTownHouseHelper(TileIndex tile, Town *t, HouseID house)
Update data structures when a house is removed.
Definition town_cmd.cpp:2934
GenRandomRoadBits
static RoadBits GenRandomRoadBits()
Generate a random road block.
Definition town_cmd.cpp:1873
CheckBuildHouseSameZ
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.
Definition town_cmd.cpp:2568
TownGenerateCargoBinominal
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
IsUniqueTownName
static bool IsUniqueTownName(const std::string &name)
Verifies this custom name is unique.
Definition town_cmd.cpp:2121
DrawTile_Town
static void DrawTile_Town(TileInfo *ti)
Draw a house and its tile.
Definition town_cmd.cpp:267
UpdateAllTownVirtCoords
void UpdateAllTownVirtCoords()
Update the virtual coords needed to draw the town sign for all towns.
Definition town_cmd.cpp:427
GrowTownInTile
static void GrowTownInTile(TileIndex *tile_ptr, RoadBits cur_rb, DiagDirection target_dir, Town *t1)
Grows the given town.
Definition town_cmd.cpp:1541
town_cmd.h
Command definitions related to towns.
town_kdtree.h
Declarations for accessing the k-d tree of towns.
town_land.h
Sprites to use and how to display them for town tiles.
_town_draw_tile_data
static const DrawBuildingsTileStruct _town_draw_tile_data[]
structure of houses graphics
Definition town_land.h:27
IncrementHouseAge
void IncrementHouseAge(Tile t)
Increments the age of the house.
Definition town_map.h:237
HaltLift
void HaltLift(Tile t)
Stop the lift of this animated house from moving.
Definition town_map.h:115
GetHouseType
HouseID GetHouseType(Tile t)
Get the type of this house, which is an index into the house spec array.
Definition town_map.h:60
ResetHouseAge
void ResetHouseAge(Tile t)
Sets the age of the house to zero.
Definition town_map.h:226
IncHouseConstructionTick
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
GetLiftPosition
uint8_t GetLiftPosition(Tile t)
Get the position of the lift on this animated house.
Definition town_map.h:125
SetLiftDestination
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
GetHouseAge
TimerGameCalendar::Year GetHouseAge(Tile t)
Get the age of the house.
Definition town_map.h:249
SetLiftPosition
void SetLiftPosition(Tile t, uint8_t pos)
Set the position of the lift on this animated house.
Definition town_map.h:135
GetLiftDestination
uint8_t GetLiftDestination(Tile t)
Get the current destination for this lift.
Definition town_map.h:104
GetHouseBuildingStage
uint8_t GetHouseBuildingStage(Tile t)
House Construction Scheme.
Definition town_map.h:183
GetTownIndex
TownID GetTownIndex(Tile t)
Get the index of which town this house/street is attached to.
Definition town_map.h:23
SetTownIndex
void SetTownIndex(Tile t, TownID index)
Set the town index for a road or house tile.
Definition town_map.h:35
LiftHasDestination
bool LiftHasDestination(Tile t)
Check if the lift of this animated house has a destination.
Definition town_map.h:82
IsHouseCompleted
bool IsHouseCompleted(Tile t)
Get the completion of this house.
Definition town_map.h:145
MakeHouseTile
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
GetHouseConstructionTick
uint8_t GetHouseConstructionTick(Tile t)
Gets the construction stage of a house.
Definition town_map.h:195
RATING_GROWTH_UP_STEP
static constexpr int RATING_GROWTH_UP_STEP
when a town grows, all companies have rating increased a bit ...
Definition town_type.h:51
RATING_INITIAL
static constexpr int RATING_INITIAL
initial rating
Definition town_type.h:43
RATING_ROAD_NEEDED_HOSTILE
static constexpr int RATING_ROAD_NEEDED_HOSTILE
"Hostile"
Definition town_type.h:69
TCGM_BITCOUNT
@ TCGM_BITCOUNT
Bit-counted algorithm (normal distribution from individual house population)
Definition town_type.h:105
TCGM_ORIGINAL
@ TCGM_ORIGINAL
Original algorithm (quadratic cargo by population)
Definition town_type.h:104
RATING_ROAD_NEEDED_NEUTRAL
static constexpr int RATING_ROAD_NEEDED_NEUTRAL
"Neutral"
Definition town_type.h:68
TownLayout
TownLayout
Town Layouts.
Definition town_type.h:79
TL_3X3_GRID
@ TL_3X3_GRID
Geometric 3x3 grid algorithm.
Definition town_type.h:84
TL_ORIGINAL
@ TL_ORIGINAL
Original algorithm (min. 1 distance between roads)
Definition town_type.h:81
TL_2X2_GRID
@ TL_2X2_GRID
Geometric 2x2 grid algorithm.
Definition town_type.h:83
TL_RANDOM
@ TL_RANDOM
Random town layout.
Definition town_type.h:86
TL_BETTER_ROADS
@ TL_BETTER_ROADS
Extended original algorithm (min. 2 distance between roads)
Definition town_type.h:82
NUM_TLS
@ NUM_TLS
Number of town layouts.
Definition town_type.h:88
RATING_TUNNEL_BRIDGE_NEEDED_LENIENT
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_LENIENT
rating needed, "Lenient" difficulty settings
Definition town_type.h:59
TF_CUSTOM_LAYOUT
@ TF_CUSTOM_LAYOUT
Allowed, with custom town layout.
Definition town_type.h:97
TF_FORBIDDEN
@ TF_FORBIDDEN
Forbidden.
Definition town_type.h:95
RATING_TUNNEL_BRIDGE_NEEDED_HOSTILE
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_HOSTILE
"Hostile"
Definition town_type.h:61
RATING_TUNNEL_BRIDGE_NEEDED_PERMISSIVE
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_PERMISSIVE
"Permissive" (local authority disabled)
Definition town_type.h:62
RATING_TUNNEL_BRIDGE_NEEDED_NEUTRAL
static constexpr int RATING_TUNNEL_BRIDGE_NEEDED_NEUTRAL
"Neutral"
Definition town_type.h:60
RATING_ROAD_NEEDED_LENIENT
static constexpr int RATING_ROAD_NEEDED_LENIENT
rating needed, "Lenient" difficulty settings
Definition town_type.h:67
TownSize
TownSize
Supported initial town sizes.
Definition town_type.h:19
TSZ_RANDOM
@ TSZ_RANDOM
Random size, bigger than small, smaller than large.
Definition town_type.h:23
TSZ_END
@ TSZ_END
Number of available town sizes.
Definition town_type.h:25
TSZ_LARGE
@ TSZ_LARGE
Large town.
Definition town_type.h:22
MAX_LENGTH_TOWN_NAME_CHARS
static const uint MAX_LENGTH_TOWN_NAME_CHARS
The maximum length of a town name in characters including '\0'.
Definition town_type.h:109
RATING_ROAD_NEEDED_PERMISSIVE
static constexpr int RATING_ROAD_NEEDED_PERMISSIVE
"Permissive" (local authority disabled)
Definition town_type.h:70
RATING_GROWTH_MAXIMUM
static constexpr int RATING_GROWTH_MAXIMUM
... up to RATING_MEDIOCRE
Definition town_type.h:52
VerifyTownName
bool VerifyTownName(uint32_t r, const TownNameParams *par, TownNames *town_names)
Verifies the town name is valid and unique.
Definition townname.cpp:103
GenerateTownName
bool GenerateTownName(Randomizer &randomizer, uint32_t *townnameparts, TownNames *town_names)
Generates valid town name.
Definition townname.cpp:136
townname_func.h
Town name generator stuff.
TO_HOUSES
@ TO_HOUSES
town buildings
Definition transparency.h:25
IsTransparencySet
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...
Definition transparency.h:48
IsInvisibilitySet
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...
Definition transparency.h:59
TransportType
TransportType
Available types of transport.
Definition transport_type.h:19
TRANSPORT_ROAD
@ TRANSPORT_ROAD
Transport by road vehicle.
Definition transport_type.h:28
tunnelbridge_cmd.h
Command definitions related to tunnels and bridges.
tunnelbridge_map.h
Functions that have tunnels and bridges in common.
GetTunnelBridgeDirection
DiagDirection GetTunnelBridgeDirection(Tile t)
Get the direction pointing to the other end.
Definition tunnelbridge_map.h:26
GetTunnelBridgeTransportType
TransportType GetTunnelBridgeTransportType(Tile t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
Definition tunnelbridge_map.h:39
GetOtherTunnelBridgeEnd
TileIndex GetOtherTunnelBridgeEnd(Tile t)
Determines type of the wormhole and returns its other end.
Definition tunnelbridge_map.h:78
AddSortableSpriteToDraw
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
AddChildSpriteScreen
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
DrawGroundSprite
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
viewport_func.h
Functions related to (drawing on) viewports.
HasTileWaterGround
bool HasTileWaterGround(Tile t)
Checks whether the tile has water at the ground.
Definition water_map.h:350
IsWaterTile
bool IsWaterTile(Tile t)
Is it a water tile with plain water?
Definition water_map.h:190
IsSea
bool IsSea(Tile t)
Is it a sea water tile?
Definition water_map.h:158
waypoint_base.h
Base of waypoints.
CloseWindowById
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
SetWindowClassesDirty
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition window.cpp:3127
InvalidateWindowData
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
SetWindowDirty
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition window.cpp:3101
window_func.h
Window functions not directly related to making/drawing windows.
WC_TOWN_AUTHORITY
@ WC_TOWN_AUTHORITY
Town authority; Window numbers:
Definition window_type.h:194
WC_STATION_VIEW
@ WC_STATION_VIEW
Station view; Window numbers:
Definition window_type.h:345
WC_TOWN_VIEW
@ WC_TOWN_VIEW
Town view; Window numbers:
Definition window_type.h:333
WC_TOWN_DIRECTORY
@ WC_TOWN_DIRECTORY
Town directory; Window numbers:
Definition window_type.h:254