OpenTTD Source 20261112-master-gbcbec5e63f
industry_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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
9
10#include "stdafx.h"
11#include "misc/history_type.hpp"
12#include "misc/history_func.hpp"
13#include "bridge_map.h"
14#include "clear_map.h"
15#include "industry.h"
16#include "station_base.h"
17#include "station_func.h"
18#include "landscape.h"
19#include "tilearea_spiral.h"
20#include "viewport_func.h"
21#include "command_func.h"
22#include "town.h"
23#include "news_func.h"
24#include "cheat_type.h"
25#include "company_base.h"
26#include "genworld.h"
27#include "tree_map.h"
28#include "newgrf_cargo.h"
29#include "newgrf_debug.h"
31#include "autoslope.h"
32#include "water.h"
33#include "strings_func.h"
34#include "window_func.h"
35#include "vehicle_func.h"
36#include "sound_func.h"
37#include "animated_tile_func.h"
38#include "effectvehicle_func.h"
39#include "effectvehicle_base.h"
40#include "ai/ai.hpp"
41#include "core/pool_func.hpp"
42#include "subsidy_func.h"
43#include "core/backup_type.hpp"
44#include "object_base.h"
45#include "game/game.hpp"
46#include "error.h"
47#include "industry_cmd.h"
48#include "landscape_cmd.h"
49#include "terraform_cmd.h"
50#include "map_func.h"
51#include "script/api/script_event_types.hpp"
52#include "timer/timer.h"
56
57#include "table/strings.h"
58#include "table/industry_land.h"
60
61#include "safeguards.h"
62
63IndustryPool _industry_pool("Industry");
65
66void ShowIndustryViewWindow(IndustryID industry);
67void BuildOilRig(TileIndex tile);
68
69static uint8_t _industry_sound_ctr;
70static TileIndex _industry_sound_tile;
71
72std::array<FlatSet<IndustryID>, NUM_INDUSTRYTYPES> Industry::industries;
73
74IndustrySpec _industry_specs[NUM_INDUSTRYTYPES];
75IndustryTileSpec _industry_tile_specs[NUM_INDUSTRYTILES];
77
78static int WhoCanServiceIndustry(Industry *ind);
79
87{
88 auto industry_insert = std::copy(std::begin(_origin_industry_specs), std::end(_origin_industry_specs), std::begin(_industry_specs));
89 std::fill(industry_insert, std::end(_industry_specs), IndustrySpec{});
90
91 /* Enable only the current climate industries */
92 for (auto it = std::begin(_industry_specs); it != industry_insert; ++it) {
93 it->enabled = it->climate_availability.Test(_settings_game.game_creation.landscape);
94 }
95
96 auto industry_tile_insert = std::copy(std::begin(_origin_industry_tile_specs), std::end(_origin_industry_tile_specs), std::begin(_industry_tile_specs));
97 std::fill(industry_tile_insert, std::end(_industry_tile_specs), IndustryTileSpec{});
98
99 /* Reset any overrides that have been set. */
100 _industile_mngr.ResetOverride();
101 _industry_mngr.ResetOverride();
102}
103
112IndustryType GetIndustryType(Tile tile)
113{
114 assert(IsTileType(tile, TileType::Industry));
115
116 const Industry *ind = Industry::GetByTile(tile);
117 assert(ind != nullptr);
118 return ind->type;
119}
120
129const IndustrySpec *GetIndustrySpec(IndustryType thistype)
130{
131 assert(thistype < NUM_INDUSTRYTYPES);
132 return &_industry_specs[thistype];
133}
134
144{
145 assert(gfx < NUM_INDUSTRYTILES);
146 return &_industry_tile_specs[gfx];
147}
148
151{
152 if (CleaningPool()) return;
153
154 /* Industry can also be destroyed when not fully initialized.
155 * This means that we do not have to clear tiles either.
156 * Also we must not decrement industry counts in that case. */
157 if (this->location.w == 0) return;
158
159 const bool has_neutral_station = this->neutral_station != nullptr;
160
161 for (TileIndex tile_cur : this->location) {
162 if (IsTileType(tile_cur, TileType::Industry)) {
163 if (GetIndustryIndex(tile_cur) == this->index) {
165
166 /* MakeWaterKeepingClass() can also handle 'land' */
167 MakeWaterKeepingClass(tile_cur, OWNER_NONE);
168 }
169 } else if (IsTileType(tile_cur, TileType::Station) && IsOilRig(tile_cur)) {
170 DeleteOilRig(tile_cur);
171 }
172 }
173
174 if (has_neutral_station) {
175 /* Remove possible docking tiles */
176 for (TileIndex tile_cur : this->location) {
178 }
179 }
180
181 if (GetIndustrySpec(this->type)->behaviour.Test(IndustryBehaviour::PlantFields)) {
182 TileArea ta = TileArea(this->location.tile, 0, 0).Expand(21);
183
184 /* Remove the farmland and convert it to regular tiles over time. */
185 for (TileIndex tile_cur : ta) {
186 if (IsTileType(tile_cur, TileType::Clear) && IsClearGround(tile_cur, ClearGround::Fields) &&
187 GetIndustryIndexOfField(tile_cur) == this->index) {
188 SetIndustryIndexOfField(tile_cur, IndustryID::Invalid());
189 }
190 }
191 }
192
193 /* don't let any disaster vehicle target invalid industry */
195
196 /* Clear the persistent storage. */
197 delete this->psa;
198
200 industries.erase(this->index);
201
203 CloseWindowById(WindowClass::IndustryView, this->index);
204 CloseWindowById(WindowClass::IndustryProductionGraph, this->index);
206
210
211 for (Station *st : this->stations_near) {
212 st->RemoveIndustryToDeliver(this);
213 }
214}
215
221{
222 InvalidateWindowData(WindowClass::IndustryDirectory, 0, IDIWD_FORCE_REBUILD);
223 SetWindowDirty(WindowClass::BuildIndustry, 0);
224}
225
226
231/* static */ Industry *Industry::GetRandom()
232{
233 if (Industry::GetNumItems() == 0) return nullptr;
234 int num = RandomRange((uint16_t)Industry::GetNumItems());
235 size_t index = std::numeric_limits<size_t>::max();
236
237 while (num >= 0) {
238 num--;
239 index++;
240
241 /* Make sure we have a valid industry */
242 while (!Industry::IsValidID(index)) {
243 index++;
244 assert(index < Industry::GetPoolSize());
245 }
246 }
247
248 return Industry::Get(index);
249}
250
251
252static void IndustryDrawSugarMine(const TileInfo *ti)
253{
254 if (!IsIndustryCompleted(ti->tile)) return;
255
257
259
260 if (d->image_2 != 0) {
261 AddChildSpriteScreen(SPR_IT_SUGAR_MINE_CLOUDS + d->image_2 - 1, PAL_NONE, 8, 41);
262 }
263
264 if (d->image_3 != 0) {
266 _drawtile_proc1[d->image_3 - 1].x, _drawtile_proc1[d->image_3 - 1].y);
267 }
268}
269
270static void IndustryDrawToffeeQuarry(const TileInfo *ti)
271{
272 uint8_t x = 0;
273
274 if (IsIndustryCompleted(ti->tile)) {
276 if (x == 0xFF) {
277 x = 0;
278 }
279 }
280
281 AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_SHOVEL, PAL_NONE, 22 - x, 24 + x);
283}
284
285static void IndustryDrawBubbleGenerator( const TileInfo *ti)
286{
287 if (IsIndustryCompleted(ti->tile)) {
289 }
291}
292
293static void IndustryDrawToyFactory(const TileInfo *ti)
294{
295 const DrawIndustryAnimationStruct *d = &_industry_anim_offs_toys[GetAnimationFrame(ti->tile)];
296
297 if (d->image_1 != 0xFF) {
299 }
300
301 if (d->image_2 != 0xFF) {
302 AddChildSpriteScreen(SPR_IT_TOY_FACTORY_ROBOT, PAL_NONE, 16 - d->image_2 * 2, 100 + d->image_2);
303 }
304
307}
308
309static void IndustryDrawCoalPlantSparks(const TileInfo *ti)
310{
311 if (IsIndustryCompleted(ti->tile)) {
312 uint8_t image = GetAnimationFrame(ti->tile);
313
314 if (image != 0 && image < 7) {
316 PAL_NONE,
317 _coal_plant_sparks[image - 1].x,
318 _coal_plant_sparks[image - 1].y
319 );
320 }
321 }
322}
323
324typedef void IndustryDrawTileProc(const TileInfo *ti);
325static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {
326 IndustryDrawSugarMine,
327 IndustryDrawToffeeQuarry,
328 IndustryDrawBubbleGenerator,
329 IndustryDrawToyFactory,
330 IndustryDrawCoalPlantSparks,
331};
332
335{
336 IndustryGfx gfx = GetIndustryGfx(ti->tile);
338 const IndustryTileSpec *indts = GetIndustryTileSpec(gfx);
339
340 /* Retrieve pointer to the draw industry tile struct */
341 if (gfx >= NEW_INDUSTRYTILEOFFSET) {
342 /* Draw the tile using the specialized method of newgrf industrytile.
343 * DrawNewIndustry will return false if ever the resolver could not
344 * find any sprite to display. So in this case, we will jump on the
345 * substitute gfx instead. */
346 if (indts->grf_prop.HasSpriteGroups() && DrawNewIndustryTile(ti, ind, gfx, indts)) {
347 return;
348 } else {
349 /* No sprite group (or no valid one) found, meaning no graphics associated.
350 * Use the substitute one instead */
351 if (indts->grf_prop.subst_id != INVALID_INDUSTRYTILE) {
352 gfx = indts->grf_prop.subst_id;
353 /* And point the industrytile spec accordingly */
354 indts = GetIndustryTileSpec(gfx);
355 }
356 }
357 }
358
359 const DrawBuildingsTileStruct *dits = &_industry_draw_tile_data[gfx << 2 | (indts->anim_state ?
362
363 SpriteID image = dits->ground.sprite;
364
365 /* DrawFoundation() modifies ti->z and ti->tileh */
367
368 /* If the ground sprite is the default flat water sprite, draw also canal/river borders.
369 * Do not do this if the tile's WaterClass is 'land'. */
370 if (image == SPR_FLAT_WATER_TILE && IsTileOnWater(ti->tile)) {
371 DrawWaterClassGround(ti);
372 } else {
374 }
375
376 /* If industries are transparent and invisible, do not draw the upper part */
378
379 /* Add industry on top of the ground? */
380 image = dits->building.sprite;
381 if (image != 0) {
384
386 }
387
388 {
389 int proc = dits->draw_proc - 1;
390 if (proc >= 0) _industry_draw_tile_procs[proc](ti);
391 }
392}
393
396{
397 IndustryGfx gfx = GetIndustryGfx(tile);
398
399 /* For NewGRF industry tiles we might not be drawing a foundation. We need to
400 * account for this, as other structures should
401 * draw the wall of the foundation in this case.
402 */
403 if (gfx >= NEW_INDUSTRYTILEOFFSET) {
404 const IndustryTileSpec *indts = GetIndustryTileSpec(gfx);
406 uint32_t callback_res = GetIndustryTileCallback(CBID_INDTILE_DRAW_FOUNDATIONS, 0, 0, gfx, Industry::GetByTile(tile), tile);
407 if (callback_res != CALLBACK_FAILED && !ConvertBooleanCallback(indts->grf_prop.grffile, CBID_INDTILE_DRAW_FOUNDATIONS, callback_res)) return Foundation::None;
408 }
409 }
410 return FlatteningFoundation(tileh);
411}
412
414static void AddAcceptedCargo_Industry(TileIndex tile, CargoArray &acceptance, CargoTypes &always_accepted)
415{
416 IndustryGfx gfx = GetIndustryGfx(tile);
417 const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);
418 const Industry *ind = Industry::GetByTile(tile);
419
420 /* Starting point for acceptance */
421 auto accepts_cargo = itspec->accepts_cargo;
422 auto cargo_acceptance = itspec->acceptance;
423
425 /* Copy all accepted cargoes from industry itself */
426 for (const auto &a : ind->accepted) {
427 auto pos = std::ranges::find(accepts_cargo, a.cargo);
428 if (pos == std::end(accepts_cargo)) {
429 /* Not found, insert */
430 pos = std::ranges::find(accepts_cargo, INVALID_CARGO);
431 if (pos == std::end(accepts_cargo)) continue; // nowhere to place, give up on this one
432 *pos = a.cargo;
433 }
434 cargo_acceptance[std::distance(std::begin(accepts_cargo), pos)] += 8;
435 }
436 }
437
439 /* Try callback for accepts list, if success override all existing accepts */
440 uint16_t res = GetIndustryTileCallback(CBID_INDTILE_ACCEPT_CARGO, 0, 0, gfx, Industry::GetByTile(tile), tile);
441 if (res != CALLBACK_FAILED) {
442 accepts_cargo.fill(INVALID_CARGO);
443 for (uint i = 0; i < INDUSTRY_ORIGINAL_NUM_INPUTS; i++) accepts_cargo[i] = GetCargoTranslation(GB(res, i * 5, 5), itspec->grf_prop.grffile);
444 }
445 }
446
448 /* Try callback for acceptance list, if success override all existing acceptance */
449 uint16_t res = GetIndustryTileCallback(CBID_INDTILE_CARGO_ACCEPTANCE, 0, 0, gfx, Industry::GetByTile(tile), tile);
450 if (res != CALLBACK_FAILED) {
451 cargo_acceptance.fill(0);
452 for (uint i = 0; i < INDUSTRY_ORIGINAL_NUM_INPUTS; i++) cargo_acceptance[i] = GB(res, i * 4, 4);
453 }
454 }
455
456 for (size_t i = 0; i < std::size(itspec->accepts_cargo); i++) {
457 CargoType cargo = accepts_cargo[i];
458 if (!IsValidCargoType(cargo) || cargo_acceptance[i] <= 0) continue; // work only with valid cargoes
459
460 /* Add accepted cargo */
461 acceptance[cargo] += cargo_acceptance[i];
462
463 /* Maybe set 'always accepted' bit (if it's not set already) */
464 if (always_accepted.Test(cargo)) continue;
465
466 /* Test whether the industry itself accepts the cargo type */
467 if (ind->IsCargoAccepted(cargo)) continue;
468
469 /* If the industry itself doesn't accept this cargo, set 'always accepted' bit */
470 always_accepted.Set(cargo);
471 }
472}
473
476{
477 const Industry *i = Industry::GetByTile(tile);
478 const IndustrySpec *is = GetIndustrySpec(i->type);
479
480 td.owner[0] = i->owner;
481 td.str = is->name;
482 if (!IsIndustryCompleted(tile)) {
483 td.dparam = td.str.base();
484 td.str = STR_LAI_TOWN_INDUSTRY_DESCRIPTION_UNDER_CONSTRUCTION;
485 }
486
487 if (is->grf_prop.HasGrfFile()) {
489 }
490}
491
494{
495 Industry *i = Industry::GetByTile(tile);
496 const IndustrySpec *indspec = GetIndustrySpec(i->type);
497
498 /* water can destroy industries
499 * in editor you can bulldoze industries
500 * with magic_bulldozer cheat you can destroy industries
501 * (area around OILRIG is water, so water shouldn't flood it
502 */
503 if ((_current_company != OWNER_WATER && _game_mode != GameMode::Editor &&
504 !_cheats.magic_bulldozer.value) ||
505 flags.Test(DoCommandFlag::Auto) ||
508 HasBit(GetIndustryTileSpec(GetIndustryGfx(tile))->slopes_refused, 5)))) {
509
510 if (flags.Test(DoCommandFlag::Auto)) {
511 return CommandCostWithParam(STR_ERROR_GENERIC_OBJECT_IN_THE_WAY, indspec->name);
512 }
514 }
515
516 if (flags.Test(DoCommandFlag::Execute)) {
517 AI::BroadcastNewEvent(new ScriptEventIndustryClose(i->index));
518 Game::NewEvent(new ScriptEventIndustryClose(i->index));
519 delete i;
520 }
522}
523
530{
531 Industry *i = Industry::GetByTile(tile);
532 const IndustrySpec *indspec = GetIndustrySpec(i->type);
533 bool moved_cargo = false;
534
535 for (auto &p : i->produced) {
536 uint cw = ClampTo<uint8_t>(p.waiting);
537 if (cw > indspec->minimal_cargo && IsValidCargoType(p.cargo)) {
538 p.waiting -= cw;
539
540 /* fluctuating economy? */
541 if (EconomyIsInRecession()) cw = (cw + 1) / 2;
542
543 p.history[THIS_MONTH].production += cw;
544
545 uint am = MoveGoodsToStation(p.cargo, cw, {i->index, SourceType::Industry}, i->stations_near, i->exclusive_consumer);
546 p.history[THIS_MONTH].transported += am;
547
548 moved_cargo |= (am != 0);
549 }
550 }
551
552 return moved_cargo;
553}
554
555static void AnimateSugarSieve(TileIndex tile)
556{
557 uint8_t m = GetAnimationFrame(tile) + 1;
558
559 if (_settings_client.sound.ambient) {
560 switch (m & 7) {
561 case 2: SndPlayTileFx(SND_2D_SUGAR_MINE_1, tile); break;
562 case 6: SndPlayTileFx(SND_29_SUGAR_MINE_2, tile); break;
563 }
564 }
565
566 if (m >= 96) {
567 m = 0;
568 DeleteAnimatedTile(tile);
569 }
570 SetAnimationFrame(tile, m);
571
573}
574
575static void AnimateToffeeQuarry(TileIndex tile)
576{
577 uint8_t m = GetAnimationFrame(tile);
578
579 if (_industry_anim_offs_toffee[m] == 0xFF && _settings_client.sound.ambient) {
580 SndPlayTileFx(SND_30_TOFFEE_QUARRY, tile);
581 }
582
583 if (++m >= 70) {
584 m = 0;
585 DeleteAnimatedTile(tile);
586 }
587 SetAnimationFrame(tile, m);
588
590}
591
592static void AnimateBubbleCatcher(TileIndex tile)
593{
594 uint8_t m = GetAnimationFrame(tile);
595
596 if (++m >= 40) {
597 m = 0;
598 DeleteAnimatedTile(tile);
599 }
600 SetAnimationFrame(tile, m);
601
603}
604
605static void AnimatePowerPlantSparks(TileIndex tile)
606{
607 uint8_t m = GetAnimationFrame(tile);
608 if (m == 6) {
609 SetAnimationFrame(tile, 0);
610 DeleteAnimatedTile(tile);
611 } else {
612 SetAnimationFrame(tile, m + 1);
613 }
615}
616
617static void AnimateToyFactory(TileIndex tile)
618{
619 uint8_t m = GetAnimationFrame(tile) + 1;
620
621 switch (m) {
622 case 1: if (_settings_client.sound.ambient) SndPlayTileFx(SND_2C_TOY_FACTORY_1, tile); break;
623 case 23: if (_settings_client.sound.ambient) SndPlayTileFx(SND_2B_TOY_FACTORY_2, tile); break;
624 case 28: if (_settings_client.sound.ambient) SndPlayTileFx(SND_2A_TOY_FACTORY_3, tile); break;
625 default:
626 if (m >= 50) {
627 int n = GetIndustryAnimationLoop(tile) + 1;
628 m = 0;
629 if (n >= 8) {
630 n = 0;
631 DeleteAnimatedTile(tile);
632 }
634 }
635 }
636
637 SetAnimationFrame(tile, m);
639}
640
641static void AnimatePlasticFountain(TileIndex tile, IndustryGfx gfx)
642{
644 SetIndustryGfx(tile, gfx);
646}
647
648static void AnimateOilWell(TileIndex tile, IndustryGfx gfx)
649{
650 bool b = Chance16(1, 7);
651 uint8_t m = GetAnimationFrame(tile) + 1;
652 if (m == 4 && (m = 0, ++gfx) == GFX_OILWELL_ANIMATED_3 + 1 && (gfx = GFX_OILWELL_ANIMATED_1, b)) {
655 DeleteAnimatedTile(tile);
656 } else {
657 SetAnimationFrame(tile, m);
658 SetIndustryGfx(tile, gfx);
659 }
661}
662
663static void AnimateMineTower(TileIndex tile)
664{
665 int state = TimerGameTick::counter & 0x7FF;
666
667 if ((state -= 0x400) < 0) return;
668
669 if (state < 0x1A0) {
670 if (state < 0x20 || state >= 0x180) {
671 uint8_t m = GetAnimationFrame(tile);
672 if (!(m & 0x40)) {
673 SetAnimationFrame(tile, m | 0x40);
674 if (_settings_client.sound.ambient) SndPlayTileFx(SND_0B_MINE, tile);
675 }
676 if (state & 7) return;
677 } else {
678 if (state & 3) return;
679 }
680 uint8_t m = (GetAnimationFrame(tile) + 1) | 0x40;
681 if (m > 0xC2) m = 0xC0;
682 SetAnimationFrame(tile, m);
684 } else if (state >= 0x200 && state < 0x3A0) {
685 int i = (state < 0x220 || state >= 0x380) ? 7 : 3;
686 if (state & i) return;
687
688 uint8_t m = (GetAnimationFrame(tile) & 0xBF) - 1;
689 if (m < 0x80) m = 0x82;
690 SetAnimationFrame(tile, m);
692 }
693}
694
697{
698 IndustryGfx gfx = GetIndustryGfx(tile);
699
700 if (GetIndustryTileSpec(gfx)->animation.status != AnimationStatus::NoAnimation) {
701 AnimateNewIndustryTile(tile);
702 return;
703 }
704
705 switch (gfx) {
707 if ((TimerGameTick::counter & 1) == 0) AnimateSugarSieve(tile);
708 break;
709
711 if ((TimerGameTick::counter & 3) == 0) AnimateToffeeQuarry(tile);
712 break;
713
715 if ((TimerGameTick::counter & 1) == 0) AnimateBubbleCatcher(tile);
716 break;
717
719 if ((TimerGameTick::counter & 3) == 0) AnimatePowerPlantSparks(tile);
720 break;
721
722 case GFX_TOY_FACTORY:
723 if ((TimerGameTick::counter & 1) == 0) AnimateToyFactory(tile);
724 break;
725
730 if ((TimerGameTick::counter & 3) == 0) AnimatePlasticFountain(tile, gfx);
731 break;
732
736 if ((TimerGameTick::counter & 7) == 0) AnimateOilWell(tile, gfx);
737 break;
738
742 AnimateMineTower(tile);
743 break;
744 }
745}
746
747static void CreateChimneySmoke(TileIndex tile)
748{
749 uint x = TileX(tile) * TILE_SIZE;
750 uint y = TileY(tile) * TILE_SIZE;
751 int z = GetTileMaxPixelZ(tile);
752
753 CreateEffectVehicle(x + 15, y + 14, z + 59, EV_CHIMNEY_SMOKE);
754}
755
756static void MakeIndustryTileBigger(TileIndex tile)
757{
758 uint8_t cnt = GetIndustryConstructionCounter(tile) + 1;
759 if (cnt != 4) {
761 return;
762 }
763
764 uint8_t stage = GetIndustryConstructionStage(tile) + 1;
766 SetIndustryConstructionStage(tile, stage);
767 TriggerIndustryTileAnimation_ConstructionStageChanged(tile, false);
768 if (stage == INDUSTRY_COMPLETED) SetIndustryCompleted(tile);
769
771
772 if (!IsIndustryCompleted(tile)) return;
773
774 IndustryGfx gfx = GetIndustryGfx(tile);
775 if (gfx >= NEW_INDUSTRYTILEOFFSET) {
776 /* New industries are already animated on construction. */
777 return;
778 }
779
780 switch (gfx) {
782 CreateChimneySmoke(tile);
783 break;
784
785 case GFX_OILRIG_1: {
786 /* Do not require an industry tile to be after the first two GFX_OILRIG_1
787 * tiles (like the default oil rig). Do a proper check to ensure the
788 * tiles belong to the same industry and based on that build the oil rig's
789 * station. */
790 TileIndex other = tile + TileDiffXY(0, 1);
791
792 if (IsTileType(other, TileType::Industry) &&
793 GetIndustryGfx(other) == GFX_OILRIG_1 &&
794 GetIndustryIndex(tile) == GetIndustryIndex(other)) {
795 BuildOilRig(tile);
796 }
797 break;
798 }
799
800 case GFX_TOY_FACTORY:
803 SetAnimationFrame(tile, 0);
805 break;
806
811 AddAnimatedTile(tile, false);
812 break;
813 }
814}
815
816static void TileLoopIndustry_BubbleGenerator(TileIndex tile)
817{
818 static const int8_t _bubble_spawn_location[3][4] = {
819 { 11, 0, -4, -14 },
820 { -4, -10, -4, 1 },
821 { 49, 59, 60, 65 },
822 };
823
824 if (_settings_client.sound.ambient) SndPlayTileFx(SND_2E_BUBBLE_GENERATOR, tile);
825
826 int dir = Random() & 3;
827
829 TileX(tile) * TILE_SIZE + _bubble_spawn_location[0][dir],
830 TileY(tile) * TILE_SIZE + _bubble_spawn_location[1][dir],
831 _bubble_spawn_location[2][dir],
833 );
834
835 if (v != nullptr) v->animation_substate = dir;
836}
837
840{
841 if (IsTileOnWater(tile)) TileLoop_Water(tile);
842
843 /* Normally this doesn't happen, but if an industry NewGRF is removed
844 * an industry that was previously build on water can now be flooded.
845 * If this happens the tile is no longer an industry tile after
846 * returning from TileLoop_Water. */
847 if (!IsTileType(tile, TileType::Industry)) return;
848
850
851 if (!IsIndustryCompleted(tile)) {
852 MakeIndustryTileBigger(tile);
853 return;
854 }
855
856 if (_game_mode == GameMode::Editor) return;
857
858 if (TransportIndustryGoods(tile) && !TriggerIndustryAnimation(Industry::GetByTile(tile), IndustryAnimationTrigger::CargoDistributed)) {
860
861 if (newgfx != INDUSTRYTILE_NOANIM) {
864 SetIndustryGfx(tile, newgfx);
866 return;
867 }
868 }
869
870 if (TriggerIndustryTileAnimation(tile, IndustryAnimationTrigger::TileLoop)) return;
871
872 IndustryGfx newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_next;
873 if (newgfx != INDUSTRYTILE_NOANIM) {
875 SetIndustryGfx(tile, newgfx);
877 return;
878 }
879
880 IndustryGfx gfx = GetIndustryGfx(tile);
881 switch (gfx) {
885 if (!(TimerGameTick::counter & 0x400) && Chance16(1, 2)) {
886 switch (gfx) {
890 }
891 SetIndustryGfx(tile, gfx);
892 SetAnimationFrame(tile, 0x80);
893 AddAnimatedTile(tile);
894 }
895 break;
896
898 if (Chance16(1, 6)) {
900 SetAnimationFrame(tile, 0);
901 AddAnimatedTile(tile);
902 }
903 break;
904
908 if (!(TimerGameTick::counter & 0x400)) {
909 switch (gfx) {
913 }
914 SetIndustryGfx(tile, gfx);
917 DeleteAnimatedTile(tile);
919 }
920 break;
921
923 if (Chance16(1, 3)) {
924 if (_settings_client.sound.ambient) SndPlayTileFx(SND_0C_POWER_STATION, tile);
925 AddAnimatedTile(tile);
926 }
927 break;
928
931 break;
932
933
934 case GFX_TOY_FACTORY: {
935 Industry *i = Industry::GetByTile(tile);
936 if (i->was_cargo_delivered) {
937 i->was_cargo_delivered = false;
939 AddAnimatedTile(tile);
940 }
941 }
942 break;
943
945 TileLoopIndustry_BubbleGenerator(tile);
946 break;
947
949 AddAnimatedTile(tile);
950 break;
951
953 if (Chance16(1, 3)) AddAnimatedTile(tile);
954 break;
955 }
956}
957
960{
961 ShowIndustryViewWindow(GetIndustryIndex(tile));
962 return true;
963}
964
966static void ChangeTileOwner_Industry(TileIndex tile, Owner old_owner, Owner new_owner)
967{
968 /* If the founder merges, the industry was created by the merged company */
969 Industry *i = Industry::GetByTile(tile);
970 if (i->founder == old_owner) i->founder = (new_owner == INVALID_OWNER) ? OWNER_NONE : new_owner;
971
972 if (i->exclusive_supplier == old_owner) i->exclusive_supplier = new_owner;
973 if (i->exclusive_consumer == old_owner) i->exclusive_consumer = new_owner;
974}
975
982{
983 /* Check for industry tile */
984 if (!IsTileType(tile, TileType::Industry)) return false;
985
986 const Industry *ind = Industry::GetByTile(tile);
987
988 /* Check for organic industry (i.e. not processing or extractive) */
990
991 /* Check for wood production */
992 return std::any_of(std::begin(ind->produced), std::end(ind->produced), [](const auto &p) { return IsValidCargoType(p.cargo) && CargoSpec::Get(p.cargo)->label == CT_WOOD; });
993}
994
995static const uint8_t _plantfarmfield_type[] = {1, 1, 1, 1, 1, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6};
996
1004static bool IsSuitableForFarmField(TileIndex tile, bool allow_fields, bool allow_rough)
1005{
1006 switch (GetTileType(tile)) {
1007 case TileType::Clear:
1008 if (IsSnowTile(tile)) return false;
1009 switch (GetClearGround(tile)) {
1010 case ClearGround::Desert: return false;
1011 case ClearGround::Rough: return allow_rough;
1012 case ClearGround::Fields: return allow_fields;
1013 default: return true;
1014 }
1015 case TileType::Trees: return GetTreeGround(tile) != TreeGround::Shore && (allow_rough || GetTreeGround(tile) != TreeGround::Rough);
1016 default: return false;
1017 }
1018}
1019
1027static void SetupFarmFieldFence(TileIndex tile, int size, uint8_t type, DiagDirection side)
1028{
1030 TileIndexDiff neighbour_diff = TileOffsByDiagDir(side);
1031
1032 do {
1033 tile = Map::WrapToMap(tile);
1034
1036 TileIndex neighbour = tile + neighbour_diff;
1037 if (!IsTileType(neighbour, TileType::Clear) || !IsClearGround(neighbour, ClearGround::Fields) || GetFence(neighbour, ReverseDiagDir(side)) == 0) {
1038 /* Add fence as long as neighbouring tile does not already have a fence in the same position. */
1039 uint8_t or_ = type;
1040
1041 if (or_ == 1 && Chance16(1, 7)) or_ = 2;
1042
1043 SetFence(tile, side, or_);
1044 }
1045 }
1046
1047 tile += diff;
1048 } while (--size);
1049}
1050
1051static void PlantFarmField(TileIndex tile, IndustryID industry)
1052{
1053 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) {
1054 if (GetTileZ(tile) + 2 >= GetSnowLine()) return;
1055 }
1056
1057 /* determine field size */
1058 uint32_t r = (Random() & 0x303) + 0x404;
1059 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) r += 0x404;
1060 uint size_x = GB(r, 0, 8);
1061 uint size_y = GB(r, 8, 8);
1062
1063 TileArea ta(tile - TileDiffXY(std::min(TileX(tile), size_x / 2), std::min(TileY(tile), size_y / 2)), size_x, size_y);
1064 ta.ClampToMap();
1065
1066 if (ta.w == 0 || ta.h == 0) return;
1067
1068 /* check the amount of bad tiles */
1069 int count = 0;
1070 for (TileIndex cur_tile : ta) {
1071 assert(cur_tile < Map::Size());
1072 count += IsSuitableForFarmField(cur_tile, false, false);
1073 }
1074 if (count * 2 < ta.w * ta.h) return;
1075
1076 /* determine type of field */
1077 r = Random();
1078 uint counter = GB(r, 5, 3);
1079 uint field_type = GB(r, 8, 8) * 9 >> 8;
1080
1081 /* make field */
1082 for (TileIndex cur_tile : ta) {
1083 assert(cur_tile < Map::Size());
1084 if (IsSuitableForFarmField(cur_tile, true, true)) {
1085 MakeField(cur_tile, field_type, industry);
1086 SetClearCounter(cur_tile, counter);
1087 MarkTileDirtyByTile(cur_tile);
1088 }
1089 }
1090
1091 int type = 3;
1092 if (_settings_game.game_creation.landscape != LandscapeType::Arctic && _settings_game.game_creation.landscape != LandscapeType::Tropic) {
1093 type = _plantfarmfield_type[Random() & 0xF];
1094 }
1095
1096 SetupFarmFieldFence(ta.tile, ta.h, type, DiagDirection::NE);
1097 SetupFarmFieldFence(ta.tile, ta.w, type, DiagDirection::NW);
1098 SetupFarmFieldFence(ta.tile + TileDiffXY(ta.w - 1, 0), ta.h, type, DiagDirection::SW);
1099 SetupFarmFieldFence(ta.tile + TileDiffXY(0, ta.h - 1), ta.w, type, DiagDirection::SE);
1100}
1101
1102void PlantRandomFarmField(const Industry *i)
1103{
1104 int x = i->location.w / 2 + Random() % 31 - 16;
1105 int y = i->location.h / 2 + Random() % 31 - 16;
1106
1107 TileIndex tile = TileAddWrap(i->location.tile, x, y);
1108
1109 if (tile != INVALID_TILE) PlantFarmField(tile, i->index);
1110}
1111
1117{
1118 /* Don't process lumber mill if cargo is not set up correctly. */
1119 auto itp = std::begin(i->produced);
1120 if (itp == std::end(i->produced) || !IsValidCargoType(itp->cargo)) return;
1121
1122 /* We only want to cut trees if all tiles are completed. */
1123 for (TileIndex tile_cur : i->location) {
1124 if (i->TileBelongsToIndustry(tile_cur)) {
1125 if (!IsIndustryCompleted(tile_cur)) return;
1126 }
1127 }
1128
1129 for (auto tile : SpiralTileSequence(i->location.tile, 40)) { // 40x40 tiles to search.
1130 if (!IsTileType(tile, TileType::Trees) || GetTreeGrowth(tile) < TreeGrowthStage::Grown) continue;
1131
1132 /* found a tree */
1133 _industry_sound_ctr = 1;
1134 _industry_sound_tile = tile;
1135 if (_settings_client.sound.ambient) SndPlayTileFx(SND_38_LUMBER_MILL_1, tile);
1136
1138 Command<Commands::LandscapeClear>::Do(DoCommandFlag::Execute, tile);
1139
1140 /* Add according value to waiting cargo. */
1141 itp->waiting = ClampTo<uint16_t>(itp->waiting + ScaleByCargoScale(45, false));
1142 break;
1143 }
1144}
1145
1151static void ProduceIndustryGoodsHelper(Industry *i, bool scale)
1152{
1153 for (auto &p : i->produced) {
1154 if (!IsValidCargoType(p.cargo)) continue;
1155
1156 uint16_t amount = p.rate;
1157 if (scale) amount = ScaleByCargoScale(amount, false);
1158
1159 p.waiting = ClampTo<uint16_t>(p.waiting + amount);
1160 }
1161}
1162
1163static void ProduceIndustryGoods(Industry *i)
1164{
1165 const IndustrySpec *indsp = GetIndustrySpec(i->type);
1166
1167 /* play a sound? */
1168 if ((i->counter & 0x3F) == 0) {
1169 uint32_t r;
1170 if (Chance16R(1, 14, r) && !indsp->random_sounds.empty() && _settings_client.sound.ambient) {
1171 if (std::any_of(std::begin(i->produced), std::end(i->produced), [](const auto &p) { return p.history[LAST_MONTH].production > 0; })) {
1172 /* Play sound since last month had production */
1173 SndPlayTileFx(
1174 static_cast<SoundFx>(indsp->random_sounds[((r >> 16) * indsp->random_sounds.size()) >> 16]),
1175 i->location.tile);
1176 }
1177 }
1178 }
1179
1180 i->counter--;
1181
1182 /* If using an industry callback, scale the callback interval by cargo scale percentage. */
1187 }
1188 }
1189
1190 /*
1191 * All other production and special effects happen every 256 ticks, and cargo production is just scaled by the cargo scale percentage.
1192 * This keeps a slow trickle of production to avoid confusion at low scale factors when the industry seems to be doing nothing for a long period of time.
1193 */
1194 if ((i->counter % Ticks::INDUSTRY_PRODUCE_TICKS) == 0) {
1195 /* Handle non-callback cargo production. */
1197
1198 IndustryBehaviours indbehav = indsp->behaviour;
1199
1200 if (indbehav.Test(IndustryBehaviour::PlantFields)) {
1201 uint16_t cb_res = CALLBACK_FAILED;
1203 cb_res = GetIndustryCallback(CBID_INDUSTRY_SPECIAL_EFFECT, Random(), 0, i, i->type, i->location.tile);
1204 }
1205
1206 bool plant;
1207 if (cb_res != CALLBACK_FAILED) {
1209 } else {
1210 plant = Chance16(1, 8);
1211 }
1212
1213 if (plant) PlantRandomFarmField(i);
1214 }
1215 if (indbehav.Test(IndustryBehaviour::CutTrees)) {
1216 uint16_t cb_res = CALLBACK_FAILED;
1218 cb_res = GetIndustryCallback(CBID_INDUSTRY_SPECIAL_EFFECT, Random(), 1, i, i->type, i->location.tile);
1219 }
1220
1221 bool cut;
1222 if (cb_res != CALLBACK_FAILED) {
1224 } else {
1225 cut = ((i->counter % Ticks::INDUSTRY_CUT_TREE_TICKS) == 0);
1226 }
1227
1228 if (cut) ChopLumberMillTrees(i);
1229 }
1230
1232 TriggerIndustryAnimation(i, IndustryAnimationTrigger::IndustryTick);
1233 }
1234}
1235
1236void OnTick_Industry()
1237{
1238 if (_industry_sound_ctr != 0) {
1239 _industry_sound_ctr++;
1240
1241 if (_industry_sound_ctr == 75) {
1242 if (_settings_client.sound.ambient) SndPlayTileFx(SND_37_LUMBER_MILL_2, _industry_sound_tile);
1243 } else if (_industry_sound_ctr == 160) {
1244 _industry_sound_ctr = 0;
1245 if (_settings_client.sound.ambient) SndPlayTileFx(SND_36_LUMBER_MILL_3, _industry_sound_tile);
1246 }
1247 }
1248
1249 if (_game_mode == GameMode::Editor) return;
1250
1251 for (Industry *i : Industry::Iterate()) {
1252 ProduceIndustryGoods(i);
1253
1254 if ((TimerGameTick::counter + i->index) % Ticks::DAY_TICKS == 0) {
1255 for (auto &a : i->accepted) a.accumulated_waiting += a.waiting;
1256 }
1257 }
1258}
1259
1265{
1266 return CommandCost();
1267}
1268
1275{
1276 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) {
1277 if (GetTileZ(tile) < HighestSnowLine() + 2) {
1278 return CommandCost(STR_ERROR_FOREST_CAN_ONLY_BE_PLANTED);
1279 }
1280 }
1281 return CommandCost();
1282}
1283
1291static bool CheckScaledDistanceFromEdge(TileIndex tile, uint maxdist)
1292{
1293 uint maxdist_x = maxdist;
1294 uint maxdist_y = maxdist;
1295
1296 if (Map::SizeX() > 256) maxdist_x *= Map::SizeX() / 256;
1297 if (Map::SizeY() > 256) maxdist_y *= Map::SizeY() / 256;
1298
1299 if (DistanceFromEdgeDir(tile, DiagDirection::NE) < maxdist_x) return true;
1300 if (DistanceFromEdgeDir(tile, DiagDirection::NW) < maxdist_y) return true;
1301 if (DistanceFromEdgeDir(tile, DiagDirection::SW) < maxdist_x) return true;
1302 if (DistanceFromEdgeDir(tile, DiagDirection::SE) < maxdist_y) return true;
1303
1304 return false;
1305}
1306
1313{
1314 if (_game_mode == GameMode::Editor) return CommandCost();
1315
1316 if (CheckScaledDistanceFromEdge(TileAddXY(tile, 1, 1), _settings_game.game_creation.oil_refinery_limit)) return CommandCost();
1317
1318 return CommandCost(STR_ERROR_CAN_ONLY_BE_POSITIONED);
1319}
1320
1321extern bool _ignore_industry_restrictions;
1322
1329{
1330 if (_game_mode == GameMode::Editor && _ignore_industry_restrictions) return CommandCost();
1331
1332 if (TileHeight(tile) == 0 &&
1333 CheckScaledDistanceFromEdge(TileAddXY(tile, 1, 1), _settings_game.game_creation.oil_refinery_limit)) return CommandCost();
1334
1335 return CommandCost(STR_ERROR_CAN_ONLY_BE_POSITIONED);
1336}
1337
1344{
1345 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) {
1346 if (GetTileZ(tile) + 2 >= HighestSnowLine()) {
1347 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1348 }
1349 }
1350 return CommandCost();
1351}
1352
1359{
1360 if (GetTropicZone(tile) == TropicZone::Desert) {
1361 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1362 }
1363 return CommandCost();
1364}
1365
1372{
1373 if (GetTropicZone(tile) != TropicZone::Desert) {
1374 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_DESERT);
1375 }
1376 return CommandCost();
1377}
1378
1385{
1387 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_RAINFOREST);
1388 }
1389 return CommandCost();
1390}
1391
1398{
1399 if (GetTileZ(tile) > 4) {
1400 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_LOW_AREAS);
1401 }
1402 return CommandCost();
1403}
1404
1411
1414 CheckNewIndustry_None, // IndustryCheck::None
1415 CheckNewIndustry_Forest, // IndustryCheck::Forest
1416 CheckNewIndustry_OilRefinery, // IndustryCheck::Refinery
1417 CheckNewIndustry_Farm, // IndustryCheck::Farm
1418 CheckNewIndustry_Plantation, // IndustryCheck::Plantation
1419 CheckNewIndustry_Water, // IndustryCheck::Water
1420 CheckNewIndustry_Lumbermill, // IndustryCheck::Lumbermill
1421 CheckNewIndustry_BubbleGen, // IndustryCheck::BubbleGen
1422 CheckNewIndustry_OilRig, // IndustryCheck::OilRig
1423};
1424
1435static CommandCost FindTownForIndustry(TileIndex tile, IndustryType type, Town **t)
1436{
1437 *t = ClosestTownFromTile(tile, UINT_MAX);
1438
1439 if (_settings_game.economy.multiple_industry_per_town) return CommandCost();
1440
1441 for (const IndustryID &industry : Industry::industries[type]) {
1442 if (Industry::Get(industry)->town == *t) {
1443 *t = nullptr;
1444 return CommandCost(STR_ERROR_ONLY_ONE_ALLOWED_PER_TOWN);
1445 }
1446 }
1447
1448 return CommandCost();
1449}
1450
1451bool IsSlopeRefused(Slope current, Slope refused)
1452{
1453 if (IsSteepSlope(current)) return true;
1454 if (current != SLOPE_FLAT) {
1455 if (IsSteepSlope(refused)) return true;
1456
1457 Slope t = ComplementSlope(current);
1458
1459 if ((refused & SLOPE_W) && (t & SLOPE_NW)) return true;
1460 if ((refused & SLOPE_S) && (t & SLOPE_NE)) return true;
1461 if ((refused & SLOPE_E) && (t & SLOPE_SW)) return true;
1462 if ((refused & SLOPE_N) && (t & SLOPE_SE)) return true;
1463 }
1464
1465 return false;
1466}
1467
1475static CommandCost CheckIfIndustryTilesAreFree(TileIndex tile, const IndustryTileLayout &layout, IndustryType type)
1476{
1477 IndustryBehaviours ind_behav = GetIndustrySpec(type)->behaviour;
1478
1479 for (const IndustryTileLayoutTile &it : layout) {
1480 IndustryGfx gfx = GetTranslatedIndustryTileID(it.gfx);
1481 TileIndex cur_tile = TileAddWrap(tile, it.ti.x, it.ti.y);
1482
1483 if (!IsValidTile(cur_tile)) {
1484 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1485 }
1486
1487 if (gfx == GFX_WATERTILE_SPECIALCHECK) {
1488 if (!IsWaterTile(cur_tile) ||
1489 !IsTileFlat(cur_tile)) {
1490 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1491 }
1492 } else {
1493 CommandCost ret = EnsureNoVehicleOnGround(cur_tile);
1494 if (ret.Failed()) return ret;
1495 if (IsBridgeAbove(cur_tile)) return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1496
1497 const IndustryTileSpec *its = GetIndustryTileSpec(gfx);
1498
1499 /* Perform land/water check if not disabled */
1500 if (!HasBit(its->slopes_refused, 5) && ((HasTileWaterClass(cur_tile) && IsTileOnWater(cur_tile)) != ind_behav.Test(IndustryBehaviour::BuiltOnWater))) return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1501
1502 if (ind_behav.Any({IndustryBehaviour::OnlyInTown, IndustryBehaviour::Town1200More}) || // Tile must be a house
1503 (ind_behav.Test(IndustryBehaviour::OnlyNearTown) && IsTileType(cur_tile, TileType::House))) { // Tile is allowed to be a house (and it is a house)
1504 if (!IsTileType(cur_tile, TileType::House)) {
1505 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_TOWNS);
1506 }
1507
1508 /* Clear the tiles as OWNER_TOWN to not affect town rating, and to not clear protected buildings */
1510 ret = Command<Commands::LandscapeClear>::Do({}, cur_tile);
1511
1512 if (ret.Failed()) return ret;
1513 } else {
1514 /* Clear the tiles, but do not affect town ratings */
1515 ret = Command<Commands::LandscapeClear>::Do({DoCommandFlag::Auto, DoCommandFlag::NoTestTownRating, DoCommandFlag::NoModifyTownRating}, cur_tile);
1516 if (ret.Failed()) return ret;
1517 }
1518 }
1519 }
1520
1521 return CommandCost();
1522}
1523
1536static CommandCost CheckIfIndustryTileSlopes(TileIndex tile, const IndustryTileLayout &layout, size_t layout_index, IndustryType type, uint16_t initial_random_bits, Owner founder, IndustryAvailabilityCallType creation_type, bool *custom_shape_check = nullptr)
1537{
1538 bool refused_slope = false;
1539 bool custom_shape = false;
1540
1541 for (const IndustryTileLayoutTile &it : layout) {
1542 IndustryGfx gfx = GetTranslatedIndustryTileID(it.gfx);
1543 TileIndex cur_tile = TileAddWrap(tile, it.ti.x, it.ti.y);
1544 assert(IsValidTile(cur_tile)); // checked before in CheckIfIndustryTilesAreFree
1545
1546 if (gfx != GFX_WATERTILE_SPECIALCHECK) {
1547 const IndustryTileSpec *its = GetIndustryTileSpec(gfx);
1548
1550 custom_shape = true;
1551 CommandCost ret = PerformIndustryTileSlopeCheck(tile, cur_tile, its, type, gfx, layout_index, initial_random_bits, founder, creation_type);
1552 if (ret.Failed()) return ret;
1553 } else {
1554 Slope tileh = GetTileSlope(cur_tile);
1555 refused_slope |= IsSlopeRefused(tileh, its->slopes_refused);
1556 }
1557 }
1558 }
1559
1560 if (custom_shape_check != nullptr) *custom_shape_check = custom_shape;
1561
1562 /* It is almost impossible to have a fully flat land in TG, so what we
1563 * do is that we check if we can make the land flat later on. See
1564 * CheckIfCanLevelIndustryPlatform(). */
1565 if (!refused_slope || (_settings_game.game_creation.land_generator == LG_TERRAGENESIS && _generating_world && !custom_shape && !_ignore_industry_restrictions)) {
1566 return CommandCost();
1567 }
1568 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1569}
1570
1578static CommandCost CheckIfIndustryIsAllowed(TileIndex tile, IndustryType type, const Town *t)
1579{
1580 if (GetIndustrySpec(type)->behaviour.Test(IndustryBehaviour::Town1200More) && t->cache.population < 1200) {
1581 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_TOWNS_WITH_POPULATION_OF_1200);
1582 }
1583
1584 if (GetIndustrySpec(type)->behaviour.Test(IndustryBehaviour::OnlyNearTown) && DistanceMax(t->xy, tile) > 9) {
1585 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_NEAR_TOWN_CENTER);
1586 }
1587
1588 return CommandCost();
1589}
1590
1591static bool CheckCanTerraformSurroundingTiles(TileIndex tile, uint height, int internal)
1592{
1593 /* Check if we don't leave the map */
1594 if (TileX(tile) == 0 || TileY(tile) == 0 || GetTileType(tile) == TileType::Void) return false;
1595
1596 TileArea ta(tile - TileDiffXY(1, 1), 2, 2);
1597 for (TileIndex tile_walk : ta) {
1598 uint curh = TileHeight(tile_walk);
1599 /* Is the tile clear? */
1600 if ((GetTileType(tile_walk) != TileType::Clear) && (GetTileType(tile_walk) != TileType::Trees)) return false;
1601
1602 /* Don't allow too big of a change if this is the sub-tile check */
1603 if (internal != 0 && Delta(curh, height) > 1) return false;
1604
1605 /* Different height, so the surrounding tiles of this tile
1606 * has to be correct too (in level, or almost in level)
1607 * else you get a chain-reaction of terraforming. */
1608 if (internal == 0 && curh != height) {
1609 if (TileX(tile_walk) == 0 || TileY(tile_walk) == 0 || !CheckCanTerraformSurroundingTiles(tile_walk + TileDiffXY(-1, -1), height, internal + 1)) {
1610 return false;
1611 }
1612 }
1613 }
1614
1615 return true;
1616}
1617
1627{
1628 int max_x = 0;
1629 int max_y = 0;
1630
1631 /* Finds dimensions of largest variant of this industry */
1632 for (const IndustryTileLayoutTile &it : layout) {
1633 if (it.gfx == GFX_WATERTILE_SPECIALCHECK) continue; // watercheck tiles don't count for footprint size
1634 if (it.ti.x > max_x) max_x = it.ti.x;
1635 if (it.ti.y > max_y) max_y = it.ti.y;
1636 }
1637
1638 /* Remember level height */
1639 uint h = TileHeight(tile);
1640
1641 if (TileX(tile) <= _settings_game.construction.industry_platform + 1U || TileY(tile) <= _settings_game.construction.industry_platform + 1U) return false;
1642 /* Check that all tiles in area and surrounding are clear
1643 * this determines that there are no obstructing items */
1644
1645 /* TileArea::Expand is not used here as we need to abort
1646 * instead of clamping if the bounds cannot expanded. */
1647 TileArea ta(tile + TileDiffXY(-_settings_game.construction.industry_platform, -_settings_game.construction.industry_platform),
1648 max_x + 2 + 2 * _settings_game.construction.industry_platform, max_y + 2 + 2 * _settings_game.construction.industry_platform);
1649
1650 if (TileX(ta.tile) + ta.w >= Map::MaxX() || TileY(ta.tile) + ta.h >= Map::MaxY()) return false;
1651
1652 /* _current_company is OWNER_NONE for randomly generated industries and in editor, or the company who funded or prospected the industry.
1653 * Perform terraforming as OWNER_TOWN to disable autoslope and town ratings. */
1655
1656 for (TileIndex tile_walk : ta) {
1657 uint curh = TileHeight(tile_walk);
1658 if (curh != h) {
1659 /* This tile needs terraforming. Check if we can do that without
1660 * damaging the surroundings too much. */
1661 if (!CheckCanTerraformSurroundingTiles(tile_walk, h, 0)) {
1662 return false;
1663 }
1664 /* This is not 100% correct check, but the best we can do without modifying the map.
1665 * What is missing, is if the difference in height is more than 1.. */
1666 if (ExtractCommandCost(Command<Commands::TerraformLand>::Do(DoCommandFlags{flags}.Reset(DoCommandFlag::Execute), tile_walk, SLOPE_N, curh <= h)).Failed()) {
1667 return false;
1668 }
1669 }
1670 }
1671
1672 if (flags.Test(DoCommandFlag::Execute)) {
1673 /* Terraform the land under the industry */
1674 for (TileIndex tile_walk : ta) {
1675 uint curh = TileHeight(tile_walk);
1676 while (curh != h) {
1677 /* We give the terraforming for free here, because we can't calculate
1678 * exact cost in the test-round, and as we all know, that will cause
1679 * a nice assert if they don't match ;) */
1680 Command<Commands::TerraformLand>::Do(flags, tile_walk, SLOPE_N, curh <= h);
1681 curh += (curh > h) ? -1 : 1;
1682 }
1683 }
1684 }
1685
1686 return true;
1687}
1688
1689
1697{
1698 const IndustrySpec *indspec = GetIndustrySpec(type);
1699
1700 for (IndustryType conflicting_type : indspec->conflicting) {
1701 if (conflicting_type == IT_INVALID) continue;
1702
1703 for (const IndustryID &industry : Industry::industries[conflicting_type]) {
1704 /* Within 14 tiles from another industry is considered close */
1705 if (DistanceMax(tile, Industry::Get(industry)->location.tile) > 14) continue;
1706
1707 return CommandCost(STR_ERROR_INDUSTRY_TOO_CLOSE);
1708 }
1709 }
1710 return CommandCost();
1711}
1712
1717static void AdvertiseIndustryOpening(const Industry *ind)
1718{
1719 const IndustrySpec *ind_spc = GetIndustrySpec(ind->type);
1720 EncodedString headline;
1721 if (ind_spc->new_industry_text > STR_LAST_STRINGID) {
1722 headline = GetEncodedString(ind_spc->new_industry_text, ind_spc->name, STR_TOWN_NAME, ind->town->index);
1723 } else {
1724 headline = GetEncodedString(ind_spc->new_industry_text, ind_spc->name, ind->town->index);
1725 }
1726 AddIndustryNewsItem(std::move(headline), NewsType::IndustryOpen, ind->index);
1727 AI::BroadcastNewEvent(new ScriptEventIndustryOpen(ind->index));
1728 Game::NewEvent(new ScriptEventIndustryOpen(ind->index));
1729}
1730
1737{
1738 if (ind->neutral_station != nullptr && !_settings_game.station.serve_neutral_industries) {
1739 /* Industry has a neutral station. Use it and ignore any other nearby stations. */
1740 ind->stations_near.insert(ind->neutral_station);
1741 ind->neutral_station->industries_near.clear();
1743 return;
1744 }
1745
1746 ForAllStationsAroundTiles(ind->location, [ind](Station *st, TileIndex tile) {
1747 if (!IsTileType(tile, TileType::Industry) || GetIndustryIndex(tile) != ind->index) return false;
1748 ind->stations_near.insert(st);
1749 st->AddIndustryToDeliver(ind, tile);
1750 return false;
1751 });
1752}
1753
1765static void DoCreateNewIndustry(Industry *i, TileIndex tile, IndustryType type, const IndustryTileLayout &layout, size_t layout_index, Town *t, Owner founder, uint16_t initial_random_bits)
1766{
1767 const IndustrySpec *indspec = GetIndustrySpec(type);
1768
1769 i->location = TileArea(tile, 1, 1);
1770 i->type = type;
1771
1772 auto &industries = Industry::industries[type];
1773 industries.insert(i->index);
1774
1775 size_t produced_count = 0;
1776 for (size_t index = 0; index < std::size(indspec->produced_cargo); ++index) {
1777 if (IsValidCargoType(indspec->produced_cargo[index])) {
1778 produced_count = index + 1;
1779 }
1780 }
1781 for (size_t index = 0; index < produced_count; ++index) {
1782 Industry::ProducedCargo &p = i->produced.emplace_back();
1783 p.cargo = indspec->produced_cargo[index];
1784 p.rate = indspec->production_rate[index];
1785 }
1786
1787 size_t accepted_count = 0;
1788 for (size_t index = 0; index < std::size(indspec->accepts_cargo); ++index) {
1789 if (IsValidCargoType(indspec->accepts_cargo[index])) {
1790 accepted_count = index + 1;
1791 }
1792 }
1793 for (size_t index = 0; index < accepted_count; ++index) {
1794 Industry::AcceptedCargo &a = i->accepted.emplace_back();
1795 a.cargo = indspec->accepts_cargo[index];
1796 }
1797
1798 /* Randomize initial production if non-original economy is used and there are no production related callbacks. */
1799 if (!indspec->UsesOriginalEconomy()) {
1800 for (auto &p : i->produced) {
1801 p.rate = ClampTo<uint8_t>((RandomRange(256) + 128) * p.rate >> 8);
1802 }
1803 }
1804
1805 i->town = t;
1806 i->owner = OWNER_NONE;
1807
1808 uint16_t r = Random();
1809 i->random_colour = static_cast<Colours>(GB(r, 0, 4));
1810 i->counter = GB(r, 4, 12);
1811 i->random = initial_random_bits;
1812 i->was_cargo_delivered = false;
1814 i->founder = founder;
1815 i->ctlflags = {};
1816
1820
1821 /* Adding 1 here makes it conform to specs of var44 of varaction2 for industries
1822 * 0 = created prior of newindustries
1823 * else, chosen layout + 1 */
1824 i->selected_layout = (uint8_t)(layout_index + 1);
1825
1828
1830
1831 /* Call callbacks after the regular fields got initialised. */
1832
1834 uint16_t res = GetIndustryCallback(CBID_INDUSTRY_PROD_CHANGE_BUILD, 0, Random(), i, type, INVALID_TILE);
1835 if (res != CALLBACK_FAILED) {
1836 if (res < PRODLEVEL_MINIMUM || res > PRODLEVEL_MAXIMUM) {
1838 } else {
1839 i->prod_level = res;
1841 }
1842 }
1843 }
1844
1845 if (_generating_world) {
1848 for (auto &p : i->produced) {
1849 if (IsValidCargoType(p.cargo)) p.history[LAST_MONTH].production = ScaleByCargoScale(p.waiting * 8, false);
1850 p.waiting = 0;
1851 }
1852 }
1853
1854 for (auto &p : i->produced) {
1855 if (IsValidCargoType(p.cargo)) p.history[LAST_MONTH].production += ScaleByCargoScale(p.rate * 8, false);
1856 }
1857
1859 }
1860
1862 uint16_t res = GetIndustryCallback(CBID_INDUSTRY_DECIDE_COLOUR, 0, 0, i, type, INVALID_TILE);
1863 if (res != CALLBACK_FAILED) {
1864 if (GB(res, 4, 11) != 0) ErrorUnknownCallbackResult(indspec->grf_prop.grfid, CBID_INDUSTRY_DECIDE_COLOUR, res);
1865 i->random_colour = static_cast<Colours>(GB(res, 0, 4));
1866 }
1867 }
1868
1870 /* Clear all input cargo types */
1871 i->accepted.clear();
1872 /* Query actual types */
1874 for (uint j = 0; j < maxcargoes; j++) {
1876 if (res == CALLBACK_FAILED || GB(res, 0, 8) == UINT8_MAX) break;
1877 if (indspec->grf_prop.grffile->grf_version >= 8 && res >= 0x100) {
1879 break;
1880 }
1881 CargoType cargo = GetCargoTranslation(GB(res, 0, 8), indspec->grf_prop.grffile);
1882 /* Industries without "unlimited" cargo types support depend on the specific order/slots of cargo types.
1883 * They need to be able to blank out specific slots without aborting the callback sequence,
1884 * and solve this by returning undefined cargo indexes. Skip these. */
1886 /* As slots are allocated as needed now, this means we do need to add a slot for the invalid cargo. */
1887 Industry::AcceptedCargo &a = i->accepted.emplace_back();
1888 a.cargo = INVALID_CARGO;
1889 continue;
1890 }
1891 /* Verify valid cargo */
1892 if (std::ranges::find(indspec->accepts_cargo, cargo) == std::end(indspec->accepts_cargo)) {
1893 /* Cargo not in spec, error in NewGRF */
1895 break;
1896 }
1897 if (std::any_of(std::begin(i->accepted), std::begin(i->accepted) + j, [&cargo](const auto &a) { return a.cargo == cargo; })) {
1898 /* Duplicate cargo */
1900 break;
1901 }
1902 Industry::AcceptedCargo &a = i->accepted.emplace_back();
1903 a.cargo = cargo;
1904 }
1905 }
1906
1908 /* Clear all output cargo types */
1909 i->produced.clear();
1910 /* Query actual types */
1912 for (uint j = 0; j < maxcargoes; j++) {
1914 if (res == CALLBACK_FAILED || GB(res, 0, 8) == UINT8_MAX) break;
1915 if (indspec->grf_prop.grffile->grf_version >= 8 && res >= 0x100) {
1917 break;
1918 }
1919 CargoType cargo = GetCargoTranslation(GB(res, 0, 8), indspec->grf_prop.grffile);
1920 /* Allow older GRFs to skip slots. */
1922 /* As slots are allocated as needed now, this means we do need to add a slot for the invalid cargo. */
1923 Industry::ProducedCargo &p = i->produced.emplace_back();
1924 p.cargo = INVALID_CARGO;
1925 continue;
1926 }
1927 /* Verify valid cargo */
1928 if (std::ranges::find(indspec->produced_cargo, cargo) == std::end(indspec->produced_cargo)) {
1929 /* Cargo not in spec, error in NewGRF */
1931 break;
1932 }
1933 if (std::any_of(std::begin(i->produced), std::begin(i->produced) + j, [&cargo](const auto &p) { return p.cargo == cargo; })) {
1934 /* Duplicate cargo */
1936 break;
1937 }
1938 Industry::ProducedCargo &p = i->produced.emplace_back();
1939 p.cargo = cargo;
1940 }
1941 }
1942
1943 /* Plant the tiles */
1944
1945 for (const IndustryTileLayoutTile &it : layout) {
1946 TileIndex cur_tile = tile + ToTileIndexDiff(it.ti);
1947
1948 if (it.gfx != GFX_WATERTILE_SPECIALCHECK) {
1949 i->location.Add(cur_tile);
1950
1951 WaterClass wc = (IsWaterTile(cur_tile) ? GetWaterClass(cur_tile) : WaterClass::Invalid);
1952
1953 Command<Commands::LandscapeClear>::Do({DoCommandFlag::Execute, DoCommandFlag::NoTestTownRating, DoCommandFlag::NoModifyTownRating}, cur_tile);
1954
1955 MakeIndustry(cur_tile, i->index, it.gfx, Random(), wc);
1956
1957 if (_generating_world) {
1958 SetIndustryConstructionCounter(cur_tile, 3);
1959 SetIndustryConstructionStage(cur_tile, 2);
1960 }
1961
1962 /* it->gfx is stored in the map. But the translated ID cur_gfx is the interesting one */
1963 IndustryGfx cur_gfx = GetTranslatedIndustryTileID(it.gfx);
1964 const IndustryTileSpec *its = GetIndustryTileSpec(cur_gfx);
1965 if (its->animation.status != AnimationStatus::NoAnimation) AddAnimatedTile(cur_tile);
1966 }
1967 }
1968
1969 /* Call callbacks after all tiles have been created. */
1970 for (TileIndex cur_tile : i->location) {
1971 if (i->TileBelongsToIndustry(cur_tile)) {
1972 /* There are no shared random bits, consistent with "MakeIndustryTileBigger" in tile loop.
1973 * So, trigger tiles individually */
1974 TriggerIndustryTileAnimation_ConstructionStageChanged(cur_tile, true);
1975 }
1976 }
1977
1979 for (uint j = 0; j != 50; j++) PlantRandomFarmField(i);
1980 }
1981 InvalidateWindowData(WindowClass::IndustryDirectory, 0, IDIWD_FORCE_REBUILD);
1982 SetWindowDirty(WindowClass::BuildIndustry, 0);
1983
1985}
1986
2003static CommandCost CreateNewIndustryHelper(TileIndex tile, IndustryType type, DoCommandFlags flags, const IndustrySpec *indspec, size_t layout_index, uint32_t random_var8f, uint16_t random_initial_bits, Owner founder, IndustryAvailabilityCallType creation_type, Industry **ip)
2004{
2005 assert(layout_index < indspec->layouts.size());
2006 const IndustryTileLayout &layout = indspec->layouts[layout_index];
2007
2008 *ip = nullptr;
2009
2010 /* 1. Cheap: Built-in checks on industry level. */
2012 if (ret.Failed()) return ret;
2013
2014 Town *t = nullptr;
2015 ret = FindTownForIndustry(tile, type, &t);
2016 if (ret.Failed()) return ret;
2017 assert(t != nullptr);
2018
2019 ret = CheckIfIndustryIsAllowed(tile, type, t);
2020 if (ret.Failed()) return ret;
2021
2022 /* 2. Built-in checks on industry tiles. */
2023 std::vector<ClearedObjectArea> object_areas(_cleared_object_areas);
2024 ret = CheckIfIndustryTilesAreFree(tile, layout, type);
2025 _cleared_object_areas = std::move(object_areas);
2026 if (ret.Failed()) return ret;
2027
2028 /* 3. NewGRF-defined checks on industry level. */
2029 if (GetIndustrySpec(type)->callback_mask.Test(IndustryCallbackMask::Location)) {
2030 ret = CheckIfCallBackAllowsCreation(tile, type, layout_index, random_var8f, random_initial_bits, founder, creation_type);
2031 } else {
2032 ret = _check_new_industry_procs[indspec->check_proc](tile);
2033 }
2034 if (ret.Failed()) return ret;
2035
2036 /* 4. Expensive: NewGRF-defined checks on industry tiles. */
2037 bool custom_shape_check = false;
2038 ret = CheckIfIndustryTileSlopes(tile, layout, layout_index, type, random_initial_bits, founder, creation_type, &custom_shape_check);
2039 if (ret.Failed()) return ret;
2040
2041 if (!custom_shape_check && _settings_game.game_creation.land_generator == LG_TERRAGENESIS && _generating_world &&
2042 !_ignore_industry_restrictions && !CheckIfCanLevelIndustryPlatform(tile, DoCommandFlag::NoWater, layout)) {
2043 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
2044 }
2045
2046 if (!Industry::CanAllocateItem()) return CommandCost(STR_ERROR_TOO_MANY_INDUSTRIES);
2047
2048 if (flags.Test(DoCommandFlag::Execute)) {
2049 *ip = Industry::Create(tile);
2050 if (!custom_shape_check) CheckIfCanLevelIndustryPlatform(tile, {DoCommandFlag::NoWater, DoCommandFlag::Execute}, layout);
2051 DoCreateNewIndustry(*ip, tile, type, layout, layout_index, t, founder, random_initial_bits);
2052 }
2053
2054 return CommandCost();
2055}
2056
2067CommandCost CmdBuildIndustry(DoCommandFlags flags, TileIndex tile, IndustryType it, uint32_t first_layout, bool fund, uint32_t seed)
2068{
2069 if (it >= NUM_INDUSTRYTYPES) return CMD_ERROR;
2070
2071 const IndustrySpec *indspec = GetIndustrySpec(it);
2072
2073 /* Check if the to-be built/founded industry is available for this climate. */
2074 if (!indspec->enabled || indspec->layouts.empty()) return CMD_ERROR;
2075
2076 /* If the setting for raw-material industries is not on, you cannot build raw-material industries.
2077 * Raw material industries are industries that do not accept cargo (at least for now) */
2078 if (_game_mode != GameMode::Editor && _current_company != OWNER_DEITY && _settings_game.construction.raw_industry_construction == 0 && indspec->IsRawIndustry()) {
2079 return CMD_ERROR;
2080 }
2081
2083 return CMD_ERROR;
2084 }
2085
2086 Randomizer randomizer;
2087 randomizer.SetSeed(seed);
2088 uint16_t random_initial_bits = GB(seed, 0, 16);
2089 uint32_t random_var8f = randomizer.Next();
2090 size_t num_layouts = indspec->layouts.size();
2091 CommandCost ret = CommandCost(STR_ERROR_SITE_UNSUITABLE);
2092 const bool deity_prospect = _current_company == OWNER_DEITY && !fund;
2093
2094 Industry *ind = nullptr;
2095 if (deity_prospect || (_game_mode != GameMode::Editor && _current_company != OWNER_DEITY && _settings_game.construction.raw_industry_construction == 2 && indspec->IsRawIndustry())) {
2096 if (flags.Test(DoCommandFlag::Execute)) {
2097 /* Prospecting has a chance to fail, however we cannot guarantee that something can
2098 * be built on the map, so the chance gets lower when the map is fuller, but there
2099 * is nothing we can really do about that. */
2100 bool prospect_success = deity_prospect || Random() <= indspec->prospecting_chance;
2101 if (prospect_success) {
2102 /* Prospected industries are build as OWNER_TOWN to not e.g. be build on owned land of the founder */
2105 for (int i = 0; i < 5000; i++) {
2106 /* We should not have more than one Random() in a function call
2107 * because parameter evaluation order is not guaranteed in the c++ standard
2108 */
2109 tile = RandomTile();
2110 /* Start with a random layout */
2111 size_t layout = RandomRange((uint32_t)num_layouts);
2112 /* Check now each layout, starting with the random one */
2113 for (size_t j = 0; j < num_layouts; j++) {
2114 layout = (layout + 1) % num_layouts;
2115 ret = CreateNewIndustryHelper(tile, it, flags, indspec, layout, random_var8f, random_initial_bits, cur_company.GetOriginalValue(), calltype, &ind);
2116 if (ret.Succeeded()) break;
2117 }
2118 if (ret.Succeeded()) break;
2119 }
2120 }
2121 if (ret.Failed() && IsLocalCompany()) {
2122 if (prospect_success) {
2123 ShowErrorMessage(GetEncodedString(STR_ERROR_CAN_T_PROSPECT_INDUSTRY), GetEncodedString(STR_ERROR_NO_SUITABLE_PLACES_FOR_PROSPECTING), WarningLevel::Info);
2124 } else {
2125 ShowErrorMessage(GetEncodedString(STR_ERROR_CAN_T_PROSPECT_INDUSTRY), GetEncodedString(STR_ERROR_PROSPECTING_WAS_UNLUCKY), WarningLevel::Info);
2126 }
2127 }
2128 }
2129 } else {
2130 size_t layout = first_layout;
2131 if (layout >= num_layouts) return CMD_ERROR;
2132
2133 /* Check subsequently each layout, starting with the given layout in p1 */
2134 for (size_t i = 0; i < num_layouts; i++) {
2135 layout = (layout + 1) % num_layouts;
2136 ret = CreateNewIndustryHelper(tile, it, flags, indspec, layout, random_var8f, random_initial_bits, _current_company, _current_company == OWNER_DEITY ? IndustryAvailabilityCallType::RandomCreation : IndustryAvailabilityCallType::UserCreation, &ind);
2137 if (ret.Succeeded()) break;
2138 }
2139
2140 /* If it still failed, there's no suitable layout to build here, return the error */
2141 if (ret.Failed()) return ret;
2142 }
2143
2144 if (flags.Test(DoCommandFlag::Execute) && ind != nullptr && _game_mode != GameMode::Editor) {
2146 }
2147
2149}
2150
2159{
2160 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2161
2162 Industry *ind = Industry::GetIfValid(ind_id);
2163 if (ind == nullptr) return CMD_ERROR;
2164 if (!ctlflags.IsValid()) return CMD_ERROR;
2165
2166 if (flags.Test(DoCommandFlag::Execute)) ind->ctlflags = ctlflags;
2167
2168 return CommandCost();
2169}
2170
2180CommandCost CmdIndustrySetProduction(DoCommandFlags flags, IndustryID ind_id, uint8_t prod_level, bool show_news, const EncodedString &custom_news)
2181{
2182 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2183 if (prod_level < PRODLEVEL_MINIMUM || prod_level > PRODLEVEL_MAXIMUM) return CMD_ERROR;
2184
2185 Industry *ind = Industry::GetIfValid(ind_id);
2186 if (ind == nullptr) return CMD_ERROR;
2187
2188 if (flags.Test(DoCommandFlag::Execute)) {
2190 ind->prod_level = prod_level;
2192
2193 /* Show news message if requested. */
2194 if (show_news && prod_level != ind->prod_level) {
2195 NewsType nt;
2196 switch (WhoCanServiceIndustry(ind)) {
2197 case 0: nt = NewsType::IndustryNobody; break;
2198 case 1: nt = NewsType::IndustryOther; break;
2199 case 2: nt = NewsType::IndustryCompany; break;
2200 default: NOT_REACHED();
2201 }
2202
2203 /* Set parameters of news string */
2204 EncodedString headline;
2205 if (!custom_news.empty()) {
2206 headline = custom_news;
2207 } else {
2208 StringID str = (prod_level > ind->prod_level)
2211
2212 if (str > STR_LAST_STRINGID) {
2213 headline = GetEncodedString(str, STR_TOWN_NAME, ind->town->index, GetIndustrySpec(ind->type)->name);
2214 } else {
2215 headline = GetEncodedString(str, ind->index);
2216 }
2217 }
2218
2219 AddIndustryNewsItem(std::move(headline), nt, ind->index);
2220 }
2221 }
2222
2223 return CommandCost();
2224}
2225
2235CommandCost CmdIndustrySetExclusivity(DoCommandFlags flags, IndustryID ind_id, Owner company_id, bool consumer)
2236{
2237 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2238
2239 Industry *ind = Industry::GetIfValid(ind_id);
2240 if (ind == nullptr) return CMD_ERROR;
2241
2242 if (company_id != OWNER_NONE && company_id != INVALID_OWNER && company_id != OWNER_DEITY
2243 && !Company::IsValidID(company_id)) return CMD_ERROR;
2244
2245 if (flags.Test(DoCommandFlag::Execute)) {
2246 if (consumer) {
2247 ind->exclusive_consumer = company_id;
2248 } else {
2249 ind->exclusive_supplier = company_id;
2250 }
2251 }
2252
2253
2254 return CommandCost();
2255}
2256
2264CommandCost CmdIndustrySetText(DoCommandFlags flags, IndustryID ind_id, const EncodedString &text)
2265{
2266 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2267
2268 Industry *ind = Industry::GetIfValid(ind_id);
2269 if (ind == nullptr) return CMD_ERROR;
2270
2271 if (flags.Test(DoCommandFlag::Execute)) {
2272 ind->text.clear();
2273 if (!text.empty()) ind->text = text;
2274 InvalidateWindowData(WindowClass::IndustryView, ind->index);
2275 }
2276
2277 return CommandCost();
2278}
2279
2287static Industry *CreateNewIndustry(TileIndex tile, IndustryType type, IndustryAvailabilityCallType creation_type)
2288{
2289 const IndustrySpec *indspec = GetIndustrySpec(type);
2290
2291 uint32_t seed = Random();
2292 uint32_t seed2 = Random();
2293 Industry *i = nullptr;
2294 size_t layout_index = RandomRange((uint32_t)indspec->layouts.size());
2295 [[maybe_unused]] CommandCost ret = CreateNewIndustryHelper(tile, type, DoCommandFlag::Execute, indspec, layout_index, seed, GB(seed2, 0, 16), OWNER_NONE, creation_type, &i);
2296 assert(i != nullptr || ret.Failed());
2297 return i;
2298}
2299
2307static uint32_t GetScaledIndustryGenerationProbability(IndustryType it, std::optional<bool> water, bool *force_at_least_one)
2308{
2309 const IndustrySpec *ind_spc = GetIndustrySpec(it);
2310 if (water.has_value() && ind_spc->behaviour.Test(IndustryBehaviour::BuiltOnWater) != *water) return 0;
2311
2312 uint32_t chance = ind_spc->appear_creation[to_underlying(_settings_game.game_creation.landscape)];
2313 if (!ind_spc->enabled || ind_spc->layouts.empty() ||
2314 (_game_mode != GameMode::Editor && _settings_game.difficulty.industry_density == IndustryDensity::FundedOnly) ||
2315 (_settings_game.economy.spawn_primary_industry_only && !ind_spc->IsRawIndustry()) ||
2317 *force_at_least_one = false;
2318 return 0;
2319 } else {
2320 chance *= 16; // to increase precision
2321 /* We want industries appearing at coast to appear less often on bigger maps, as length of coast increases slower than map area.
2322 * For simplicity we scale in both cases, though scaling the probabilities of all industries has no effect. */
2323 chance = (ind_spc->check_proc == IndustryCheck::Refinery || ind_spc->check_proc == IndustryCheck::OilRig) ? Map::ScaleBySize1D(chance) : Map::ScaleBySize(chance);
2324
2325 *force_at_least_one = (chance > 0) && !ind_spc->behaviour.Test(IndustryBehaviour::NoBuildMapCreation) && (_game_mode != GameMode::Editor);
2326 return chance;
2327 }
2328}
2329
2336static uint16_t GetIndustryGamePlayProbability(IndustryType it, uint8_t *min_number)
2337{
2338 if (_settings_game.difficulty.industry_density == IndustryDensity::FundedOnly) {
2339 *min_number = 0;
2340 return 0;
2341 }
2342
2343 const IndustrySpec *ind_spc = GetIndustrySpec(it);
2344 if (_settings_game.economy.spawn_primary_industry_only && !ind_spc->IsRawIndustry()) {
2345 *min_number = 0;
2346 return 0;
2347 }
2348
2349 uint8_t chance = ind_spc->appear_ingame[to_underlying(_settings_game.game_creation.landscape)];
2350 if (!ind_spc->enabled || ind_spc->layouts.empty() ||
2354 *min_number = 0;
2355 return 0;
2356 }
2357 *min_number = ind_spc->behaviour.Test(IndustryBehaviour::CanCloseLastInstance) ? 1 : 0;
2358 return chance;
2359}
2360
2366{
2367 /* Number of industries on a 256x256 map. */
2368 static const uint16_t numof_industry_table[] = {
2369 0, // none
2370 0, // minimal
2371 10, // very low
2372 25, // low
2373 55, // normal
2374 80, // high
2375 0, // custom
2376 };
2377
2378 assert(lengthof(numof_industry_table) == to_underlying(IndustryDensity::End));
2379 IndustryDensity density = (_game_mode != GameMode::Editor) ? _settings_game.difficulty.industry_density : IndustryDensity::VeryLow;
2380
2381 if (density == IndustryDensity::Custom) return std::min<uint>(IndustryPool::MAX_SIZE, _settings_game.game_creation.custom_industry_number);
2382
2383 return std::min<uint>(IndustryPool::MAX_SIZE, Map::ScaleBySize(numof_industry_table[to_underlying(density)]));
2384}
2385
2395static Industry *PlaceIndustry(IndustryType type, IndustryAvailabilityCallType creation_type, bool try_hard)
2396{
2397 uint tries = try_hard ? 10000u : 2000u;
2398 for (; tries > 0; tries--) {
2399 Industry *ind = CreateNewIndustry(RandomTile(), type, creation_type);
2400 if (ind != nullptr) return ind;
2401 }
2402 return nullptr;
2403}
2404
2418
2424{
2425 uint total = 0;
2426 for (const auto &industries : Industry::industries) {
2427 total += static_cast<uint16_t>(std::size(industries));
2428 }
2429 return total;
2430}
2431
2432
2435{
2436 this->probability = 0;
2437 this->min_number = 0;
2438 this->target_count = 0;
2439 this->max_wait = 1;
2440 this->wait_count = 0;
2441}
2442
2445{
2447
2448 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2449 this->builddata[it].Reset();
2450 }
2451}
2452
2455{
2456 static const int NEWINDS_PER_MONTH = 0x38000 / (10 * 12); // lower 16 bits is a float fraction, 3.5 industries per decade, divided by 10 * 12 months.
2457 if (_settings_game.difficulty.industry_density == IndustryDensity::FundedOnly) return; // 'no industries' setting.
2458
2459 /* To prevent running out of unused industries for the player to connect,
2460 * add a fraction of new industries each month, but only if the manager can keep up. */
2461 uint max_behind = 1 + std::min(99u, Map::ScaleBySize(3)); // At most 2 industries for small maps, and 100 at the biggest map (about 6 months industry build attempts).
2462 if (GetCurrentTotalNumberOfIndustries() + max_behind >= (this->wanted_inds >> 16)) {
2463 this->wanted_inds += Map::ScaleBySize(NEWINDS_PER_MONTH);
2464 }
2465}
2466
2468 std::array<uint32_t, NUM_INDUSTRYTYPES> probs{};
2469 std::array<bool, NUM_INDUSTRYTYPES> force_one{};
2470 uint64_t total = 0;
2471 uint num_forced = 0;
2472};
2473
2480{
2482
2483 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2484 p.probs[it] = GetScaledIndustryGenerationProbability(it, water, &p.force_one[it]);
2485 p.total += p.probs[it];
2486 if (p.force_one[it]) p.num_forced++;
2487 }
2488
2489 return p;
2490}
2491
2497{
2498 if (_game_mode != GameMode::Editor && _settings_game.difficulty.industry_density == IndustryDensity::FundedOnly) return; // No industries in the game.
2499
2500 /* Get the probabilities for all industries. This is done first as we need the total of
2501 * both land and water for scaling later. */
2504
2505 /* Run generation twice, for land and water industries in turn. */
2506 for (bool water = false;; water = true) {
2507 auto &p = water ? wprob : lprob;
2508
2509 /* Total number of industries scaled by land/water proportion. */
2510 uint total_amount = 0;
2511 if (lprob.total + wprob.total > 0) total_amount = p.total * GetNumberOfIndustries() / (lprob.total + wprob.total);
2512
2513 /* Scale land-based industries to the land proportion, unless the player has set a custom industry count. */
2514 if (!water && _settings_game.difficulty.industry_density != IndustryDensity::Custom) total_amount = Map::ScaleByLandProportion(total_amount);
2515
2516 /* Ensure that forced industries are generated even if the scaled amounts are too low. */
2517 if (p.total == 0 || total_amount < p.num_forced) {
2518 /* Only place the forced ones */
2519 total_amount = p.num_forced;
2520 }
2521
2523
2524 /* Try to build one industry per type independent of any probabilities */
2525 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2526 if (p.force_one[it]) {
2527 assert(total_amount > 0);
2528 total_amount--;
2529 PlaceInitialIndustry(it, water, true);
2530 }
2531 }
2532
2533 /* Add the remaining industries according to their probabilities */
2534 for (uint i = 0; i < total_amount; i++) {
2535 uint32_t r = RandomRange(p.total);
2536 IndustryType it = 0;
2537 while (r >= p.probs[it]) {
2538 r -= p.probs[it];
2539 it++;
2540 assert(it < NUM_INDUSTRYTYPES);
2541 }
2542 assert(p.probs[it] > 0);
2543 PlaceInitialIndustry(it, water, false);
2544 }
2545
2546 if (water) break;
2547 }
2548
2549 _industry_builder.Reset();
2550}
2551
2552template <>
2553Industry::ProducedHistory SumHistory(std::span<const Industry::ProducedHistory> history)
2554{
2555 uint32_t production = std::accumulate(std::begin(history), std::end(history), 0, [](uint32_t r, const auto &p) { return r + p.production; });
2556 uint32_t transported = std::accumulate(std::begin(history), std::end(history), 0, [](uint32_t r, const auto &p) { return r + p.transported; });
2557 auto count = std::size(history);
2558 return {.production = ClampTo<uint16_t>(production / count), .transported = ClampTo<uint16_t>(transported / count)};
2559}
2560
2561template <>
2562Industry::AcceptedHistory SumHistory(std::span<const Industry::AcceptedHistory> history)
2563{
2564 uint32_t accepted = std::accumulate(std::begin(history), std::end(history), 0, [](uint32_t r, const auto &a) { return r + a.accepted; });
2565 uint32_t waiting = std::accumulate(std::begin(history), std::end(history), 0, [](uint32_t r, const auto &a) { return r + a.waiting; });;
2566 auto count = std::size(history);
2567 return {.accepted = ClampTo<uint16_t>(accepted / count), .waiting = ClampTo<uint16_t>(waiting / count)};
2568}
2569
2575{
2576 auto month = TimerGameEconomy::month;
2577 UpdateValidHistory(i->valid_history, HISTORY_YEAR, month);
2578
2579 for (auto &p : i->produced) {
2580 if (IsValidCargoType(p.cargo)) {
2581 if (p.history[THIS_MONTH].production != 0) i->last_prod_year = TimerGameEconomy::year;
2582
2583 RotateHistory(p.history, i->valid_history, HISTORY_YEAR, month);
2584 }
2585 }
2586
2587 for (auto &a : i->accepted) {
2588 if (!IsValidCargoType(a.cargo)) continue;
2589 if (a.history == nullptr) continue;
2590
2591 (*a.history)[THIS_MONTH].waiting = GetAndResetAccumulatedAverage<uint16_t>(a.accumulated_waiting);
2592 RotateHistory(*a.history, i->valid_history, HISTORY_YEAR, month);
2593 }
2594}
2595
2601{
2602 const IndustrySpec *indspec = GetIndustrySpec(this->type);
2603 assert(indspec->UsesOriginalEconomy());
2604
2605 /* Rates are rounded up, so e.g. oilrig always produces some passengers */
2606 for (auto &p : this->produced) {
2607 p.rate = ClampTo<uint8_t>(CeilDiv(indspec->production_rate[&p - this->produced.data()] * this->prod_level, PRODLEVEL_DEFAULT));
2608 }
2609}
2610
2611void Industry::FillCachedName() const
2612{
2613 auto tmp_params = MakeParameters(this->index);
2614 this->cached_name = GetStringWithArgs(STR_INDUSTRY_NAME, tmp_params);
2615}
2616
2617void ClearAllIndustryCachedNames()
2618{
2619 for (Industry *ind : Industry::Iterate()) {
2620 ind->cached_name.clear();
2621 }
2622}
2623
2630{
2631 uint8_t min_number;
2633 bool changed = min_number != this->min_number || probability != this->probability;
2634 this->min_number = min_number;
2635 this->probability = probability;
2636 return changed;
2637}
2638
2641{
2642 bool changed = false;
2643 uint num_planned = 0; // Number of industries planned in the industry build data.
2644 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2645 changed |= this->builddata[it].GetIndustryTypeData(it);
2646 num_planned += this->builddata[it].target_count;
2647 }
2648 uint total_amount = this->wanted_inds >> 16; // Desired total number of industries.
2649 changed |= num_planned != total_amount;
2650 if (!changed) return; // All industries are still the same, no need to re-randomize.
2651
2652 /* Initialize the target counts. */
2653 uint force_build = 0; // Number of industries that should always be available.
2654 uint32_t total_prob = 0; // Sum of probabilities.
2655 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2656 IndustryTypeBuildData *ibd = this->builddata + it;
2657 force_build += ibd->min_number;
2658 ibd->target_count = ibd->min_number;
2659 total_prob += ibd->probability;
2660 }
2661
2662 if (total_prob == 0) return; // No buildable industries.
2663
2664 /* Subtract forced industries from the number of industries available for construction. */
2665 total_amount = (total_amount <= force_build) ? 0 : total_amount - force_build;
2666
2667 /* Assign number of industries that should be aimed for, by using the probability as a weight. */
2668 while (total_amount > 0) {
2669 uint32_t r = RandomRange(total_prob);
2670 IndustryType it = 0;
2671 while (r >= this->builddata[it].probability) {
2672 r -= this->builddata[it].probability;
2673 it++;
2674 assert(it < NUM_INDUSTRYTYPES);
2675 }
2676 assert(this->builddata[it].probability > 0);
2677 this->builddata[it].target_count++;
2678 total_amount--;
2679 }
2680}
2681
2686{
2687 this->SetupTargetCount();
2688
2689 int missing = 0; // Number of industries that need to be build.
2690 uint count = 0; // Number of industry types eligible for build.
2691 uint32_t total_prob = 0; // Sum of probabilities.
2692 IndustryType forced_build = NUM_INDUSTRYTYPES; // Industry type that should be forcibly build.
2693 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2694 int difference = this->builddata[it].target_count - Industry::GetIndustryTypeCount(it);
2695 missing += difference;
2696 if (this->builddata[it].wait_count > 0) continue; // This type may not be built now.
2697 if (difference > 0) {
2698 if (Industry::GetIndustryTypeCount(it) == 0 && this->builddata[it].min_number > 0) {
2699 /* An industry that should exist at least once, is not available. Force it, trying the most needed one first. */
2700 if (forced_build == NUM_INDUSTRYTYPES ||
2701 difference > this->builddata[forced_build].target_count - Industry::GetIndustryTypeCount(forced_build)) {
2702 forced_build = it;
2703 }
2704 }
2705 total_prob += difference;
2706 count++;
2707 }
2708 }
2709
2710 if (EconomyIsInRecession() || (forced_build == NUM_INDUSTRYTYPES && (missing <= 0 || total_prob == 0))) count = 0; // Skip creation of an industry.
2711
2712 if (count >= 1) {
2713 /* If not forced, pick a weighted random industry to build.
2714 * For the case that count == 1, there is no need to draw a random number. */
2715 IndustryType it;
2716 if (forced_build != NUM_INDUSTRYTYPES) {
2717 it = forced_build;
2718 } else {
2719 /* Non-forced, select an industry type to build (weighted random). */
2720 uint32_t r = 0; // Initialized to silence the compiler.
2721 if (count > 1) r = RandomRange(total_prob);
2722 for (it = 0; it < NUM_INDUSTRYTYPES; it++) {
2723 if (this->builddata[it].wait_count > 0) continue; // Type may not be built now.
2724 int difference = this->builddata[it].target_count - Industry::GetIndustryTypeCount(it);
2725 if (difference <= 0) continue; // Too many of this kind.
2726 if (count == 1) break;
2727 if (r < (uint)difference) break;
2728 r -= difference;
2729 }
2730 assert(it < NUM_INDUSTRYTYPES && this->builddata[it].target_count > Industry::GetIndustryTypeCount(it));
2731 }
2732
2733 /* Try to create the industry. */
2735 if (ind == nullptr) {
2736 this->builddata[it].wait_count = this->builddata[it].max_wait + 1; // Compensate for decrementing below.
2737 this->builddata[it].max_wait = std::min(1000, this->builddata[it].max_wait + 2);
2738 } else {
2740 this->builddata[it].max_wait = std::max(this->builddata[it].max_wait / 2, 1); // Reduce waiting time of the industry type.
2741 }
2742 }
2743
2744 /* Decrement wait counters. */
2745 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2746 if (this->builddata[it].wait_count > 0) this->builddata[it].wait_count--;
2747 }
2748}
2749
2758static bool CheckIndustryCloseDownProtection(IndustryType type)
2759{
2760 const IndustrySpec *indspec = GetIndustrySpec(type);
2761
2762 /* oil wells (or the industries with that flag set) are always allowed to closedown */
2763 if (indspec->behaviour.Test(IndustryBehaviour::DontIncrProd) && _settings_game.game_creation.landscape == LandscapeType::Temperate) return false;
2765}
2766
2776static void CanCargoServiceIndustry(CargoType cargo, Industry *ind, bool *c_accepts, bool *c_produces)
2777{
2778 if (!IsValidCargoType(cargo)) return;
2779
2780 /* Check for acceptance of cargo */
2781 if (ind->IsCargoAccepted(cargo) && !IndustryTemporarilyRefusesCargo(ind, cargo)) *c_accepts = true;
2782
2783 /* Check for produced cargo */
2784 if (ind->IsCargoProduced(cargo)) *c_produces = true;
2785}
2786
2801{
2802 if (ind->stations_near.empty()) return 0; // No stations found at all => nobody services
2803
2804 int result = 0;
2805 for (const Vehicle *v : Vehicle::Iterate()) {
2806 /* Is it worthwhile to try this vehicle? */
2807 if (v->owner != _local_company && result != 0) continue;
2808
2809 /* Check whether it accepts the right kind of cargo */
2810 bool c_accepts = false;
2811 bool c_produces = false;
2812 if (v->type == VehicleType::Train && v->IsFrontEngine()) {
2813 for (const Vehicle *u = v; u != nullptr; u = u->Next()) {
2814 CanCargoServiceIndustry(u->cargo_type, ind, &c_accepts, &c_produces);
2815 }
2816 } else if (v->type == VehicleType::Road || v->type == VehicleType::Ship || v->type == VehicleType::Aircraft) {
2817 CanCargoServiceIndustry(v->cargo_type, ind, &c_accepts, &c_produces);
2818 } else {
2819 continue;
2820 }
2821 if (!c_accepts && !c_produces) continue; // Wrong cargo
2822
2823 /* Check orders of the vehicle.
2824 * We cannot check the first of shared orders only, since the first vehicle in such a chain
2825 * may have a different cargo type.
2826 */
2827 for (const Order &o : v->Orders()) {
2828 if (o.IsType(OT_GOTO_STATION) && o.GetUnloadType() != OrderUnloadType::Transfer) {
2829 /* Vehicle visits a station to load or unload */
2830 Station *st = Station::Get(o.GetDestination().ToStationID());
2831 assert(st != nullptr);
2832
2833 /* Same cargo produced by industry is dropped here => not serviced by vehicle v */
2834 if (o.GetUnloadType() == OrderUnloadType::Unload && !c_accepts) break;
2835
2836 if (ind->stations_near.find(st) != ind->stations_near.end()) {
2837 if (v->owner == _local_company) return 2; // Company services industry
2838 result = 1; // Competitor services industry
2839 }
2840 }
2841 }
2842 }
2843 return result;
2844}
2845
2853static void ReportNewsProductionChangeIndustry(Industry *ind, CargoType cargo, int percent)
2854{
2855 NewsType nt;
2856
2857 switch (WhoCanServiceIndustry(ind)) {
2858 case 0: nt = NewsType::IndustryNobody; break;
2859 case 1: nt = NewsType::IndustryOther; break;
2860 case 2: nt = NewsType::IndustryCompany; break;
2861 default: NOT_REACHED();
2862 }
2863 AddIndustryNewsItem(
2864 GetEncodedString(percent >= 0 ? STR_NEWS_INDUSTRY_PRODUCTION_INCREASE_SMOOTH : STR_NEWS_INDUSTRY_PRODUCTION_DECREASE_SMOOTH,
2865 CargoSpec::Get(cargo)->name, ind->index, abs(percent)
2866 ),
2867 nt,
2868 ind->index
2869 );
2870}
2871
2872static const uint PERCENT_TRANSPORTED_60 = 153;
2873static const uint PERCENT_TRANSPORTED_80 = 204;
2874
2880static void ChangeIndustryProduction(Industry *i, bool monthly)
2881{
2882 StringID str = STR_NULL;
2883 bool closeit = false;
2884 const IndustrySpec *indspec = GetIndustrySpec(i->type);
2885 bool standard = false;
2886 bool suppress_message = false;
2887 bool recalculate_multipliers = false;
2888 /* use original economy for industries using production related callbacks */
2889 bool original_economy = indspec->UsesOriginalEconomy();
2890 uint8_t div = 0;
2891 uint8_t mul = 0;
2892 int8_t increment = 0;
2893
2895 if (callback_enabled) {
2896 std::array<int32_t, 1> regs100;
2897 uint16_t res = GetIndustryCallback(monthly ? CBID_INDUSTRY_MONTHLYPROD_CHANGE : CBID_INDUSTRY_PRODUCTION_CHANGE, 0, Random(), i, i->type, i->location.tile, regs100);
2898 if (res != CALLBACK_FAILED) { // failed callback means "do nothing"
2899 suppress_message = HasBit(res, 7);
2900 /* Get the custom message if any */
2901 if (HasBit(res, 8)) str = MapGRFStringID(indspec->grf_prop.grfid, GRFStringID(GB(regs100[0], 0, 16)));
2902 res = GB(res, 0, 4);
2903 switch (res) {
2904 default: NOT_REACHED();
2905 case 0x0: break; // Do nothing, but show the custom message if any
2906 case 0x1: div = 1; break; // Halve industry production. If production reaches the quarter of the default, the industry is closed instead.
2907 case 0x2: mul = 1; break; // Double industry production if it hasn't reached eight times of the original yet.
2908 case 0x3: closeit = true; break; // The industry announces imminent closure, and is physically removed from the map next month.
2909 case 0x4: standard = true; break; // Do the standard random production change as if this industry was a primary one.
2910 case 0x5: case 0x6: case 0x7: // Divide production by 4, 8, 16
2911 case 0x8: div = res - 0x3; break; // Divide production by 32
2912 case 0x9: case 0xA: case 0xB: // Multiply production by 4, 8, 16
2913 case 0xC: mul = res - 0x7; break; // Multiply production by 32
2914 case 0xD: // decrement production
2915 case 0xE: // increment production
2916 increment = res == 0x0D ? -1 : 1;
2917 break;
2918 case 0xF: // Set production to third byte of register 0x100
2919 i->prod_level = Clamp(GB(regs100[0], 16, 8), PRODLEVEL_MINIMUM, PRODLEVEL_MAXIMUM);
2920 recalculate_multipliers = true;
2921 break;
2922 }
2923 }
2924 } else {
2925 if (monthly == original_economy) return;
2926 if (!original_economy && _settings_game.economy.type == EconomyType::Frozen) return;
2927 if (indspec->life_type == INDUSTRYLIFE_BLACK_HOLE) return;
2928 }
2929
2930 if (standard || (!callback_enabled && indspec->life_type.Any({IndustryLifeType::Organic, IndustryLifeType::Extractive}))) {
2931 /* decrease or increase */
2932 bool only_decrease = indspec->behaviour.Test(IndustryBehaviour::DontIncrProd) && _settings_game.game_creation.landscape == LandscapeType::Temperate;
2933
2934 if (original_economy) {
2935 if (only_decrease || Chance16(1, 3)) {
2936 /* If more than 60% transported, 66% chance of increase, else 33% chance of increase */
2937 if (!only_decrease && (i->GetProduced(0).history[LAST_MONTH].PctTransported() > PERCENT_TRANSPORTED_60) != Chance16(1, 3)) {
2938 mul = 1; // Increase production
2939 } else {
2940 div = 1; // Decrease production
2941 }
2942 }
2943 } else if (_settings_game.economy.type == EconomyType::Smooth) {
2945 for (auto &p : i->produced) {
2946 if (!IsValidCargoType(p.cargo)) continue;
2947 uint32_t r = Random();
2948 int old_prod, new_prod, percent;
2949 new_prod = old_prod = p.rate;
2950
2951 /* 1 in 22 chance to change production rate, randomly up/down depending on percent transported last month */
2952 if (Chance16I(1, 22, r >> 16)) {
2953 int prod_change_direction;
2954 if (only_decrease) {
2955 prod_change_direction = -1;
2956 } else if (p.history[LAST_MONTH].PctTransported() <= PERCENT_TRANSPORTED_60) {
2957 prod_change_direction = Chance16I(1, 3, r) ? 1 : -1;
2958 } else if (p.history[LAST_MONTH].PctTransported() <= PERCENT_TRANSPORTED_80) {
2959 prod_change_direction = Chance16I(2, 3, r) ? 1 : -1;
2960 } else {
2961 prod_change_direction = Chance16I(5, 6, r) ? 1 : -1;
2962 }
2963 new_prod += prod_change_direction * (std::max(((RandomRange(50) + 10) * old_prod) >> 8, 1U));
2964 }
2965
2966 /* Prevent production to overflow or Oil Rig passengers to be over-"produced" */
2967 new_prod = Clamp(new_prod, 1, 255);
2969 new_prod = Clamp(new_prod, 0, 16);
2970 }
2971
2972 /* If override flags are set, prevent actually changing production if any was decided on */
2973 if (i->ctlflags.Test(IndustryControlFlag::NoProductionDecrease) && new_prod < old_prod) continue;
2974 if (i->ctlflags.Test(IndustryControlFlag::NoProductionIncrease) && new_prod > old_prod) continue;
2975
2976 /* Do not stop closing the industry when it has the lowest possible production rate */
2977 if (new_prod == old_prod && old_prod > 1) {
2978 closeit = false;
2979 continue;
2980 }
2981
2982 percent = (old_prod == 0) ? 100 : (new_prod * 100 / old_prod - 100);
2983 p.rate = new_prod;
2984
2985 /* Close the industry when it has the lowest possible production rate */
2986 if (new_prod > 1) closeit = false;
2987
2988 if (abs(percent) >= 10) {
2989 ReportNewsProductionChangeIndustry(i, p.cargo, percent);
2990 }
2991 }
2992 }
2993 }
2994
2995 /* If override flags are set, prevent actually changing production if any was decided on */
2996 if (i->ctlflags.Test(IndustryControlFlag::NoProductionDecrease) && (div > 0 || increment < 0)) return;
2997 if (i->ctlflags.Test(IndustryControlFlag::NoProductionIncrease) && (mul > 0 || increment > 0)) return;
2999 div = 0;
3000 mul = 0;
3001 increment = 0;
3002 }
3003
3004 if (!callback_enabled && indspec->life_type.Test(IndustryLifeType::Processing)) {
3005 if (TimerGameEconomy::year - i->last_prod_year >= PROCESSING_INDUSTRY_ABANDONMENT_YEARS && Chance16(1, original_economy ? 2 : 180)) {
3006 closeit = true;
3007 }
3008 }
3009
3010 /* Increase if needed */
3011 while (mul-- != 0 && i->prod_level < PRODLEVEL_MAXIMUM) {
3012 i->prod_level = std::min<int>(i->prod_level * 2, PRODLEVEL_MAXIMUM);
3013 recalculate_multipliers = true;
3014 if (str == STR_NULL) str = indspec->production_up_text;
3015 }
3016
3017 /* Decrease if needed */
3018 while (div-- != 0 && !closeit) {
3019 if (i->prod_level == PRODLEVEL_MINIMUM) {
3020 closeit = true;
3021 break;
3022 } else {
3023 i->prod_level = std::max<int>(i->prod_level / 2, PRODLEVEL_MINIMUM);
3024 recalculate_multipliers = true;
3025 if (str == STR_NULL) str = indspec->production_down_text;
3026 }
3027 }
3028
3029 /* Increase or Decreasing the production level if needed */
3030 if (increment != 0) {
3031 if (increment < 0 && i->prod_level == PRODLEVEL_MINIMUM) {
3032 closeit = true;
3033 } else {
3035 recalculate_multipliers = true;
3036 }
3037 }
3038
3039 /* Recalculate production_rate
3040 * For non-smooth economy these should always be synchronized with prod_level */
3041 if (recalculate_multipliers) i->RecomputeProductionMultipliers();
3042
3043 /* Close if needed and allowed */
3046 SetWindowDirty(WindowClass::IndustryView, i->index);
3047 str = indspec->closure_text;
3048 }
3049
3050 if (!suppress_message && str != STR_NULL) {
3051 NewsType nt;
3052 /* Compute news category */
3053 if (closeit) {
3054 switch (WhoCanServiceIndustry(i)) {
3055 case 0: nt = NewsType::IndustryCloseNobody; break;
3056 case 1: nt = NewsType::IndustryCloseOther; break;
3057 case 2: nt = NewsType::IndustryCloseCompany; break;
3058 default: NOT_REACHED();
3059 }
3060
3061 AI::BroadcastNewEvent(new ScriptEventIndustryClose(i->index));
3062 Game::NewEvent(new ScriptEventIndustryClose(i->index));
3063 } else {
3064 switch (WhoCanServiceIndustry(i)) {
3065 case 0: nt = NewsType::IndustryNobody; break;
3066 case 1: nt = NewsType::IndustryOther; break;
3067 case 2: nt = NewsType::IndustryCompany; break;
3068 default: NOT_REACHED();
3069 }
3070 }
3071 /* Set parameters of news string */
3072 EncodedString headline;
3073 if (str > STR_LAST_STRINGID) {
3074 headline = GetEncodedString(str, STR_TOWN_NAME, i->town->index, indspec->name);
3075 } else if (closeit) {
3076 headline = GetEncodedString(str, STR_FORMAT_INDUSTRY_NAME, i->town->index, indspec->name);
3077 } else {
3078 headline = GetEncodedString(str, i->index);
3079 }
3080 /* and report the news to the user */
3081 if (closeit) {
3082 AddTileNewsItem(std::move(headline), nt, i->location.tile + TileDiffXY(1, 1));
3083 } else {
3084 AddIndustryNewsItem(std::move(headline), nt, i->index);
3085 }
3086 }
3087}
3088
3096static const IntervalTimer<TimerGameEconomy> _economy_industries_daily({TimerGameEconomy::Trigger::Day, TimerGameEconomy::Priority::Industry}, [](auto)
3097{
3098 _economy.industry_daily_change_counter += _economy.industry_daily_increment;
3099
3100 /* Bits 16-31 of industry_construction_counter contain the number of industries to change/create today,
3101 * the lower 16 bit are a fractional part that might accumulate over several days until it
3102 * is sufficient for an industry. */
3103 uint16_t change_loop = _economy.industry_daily_change_counter >> 16;
3104
3105 /* Reset the active part of the counter, just keeping the "fractional part" */
3106 _economy.industry_daily_change_counter &= 0xFFFF;
3107
3108 if (change_loop == 0) {
3109 return; // Nothing to do? get out
3110 }
3111
3113
3114 /* perform the required industry changes for the day */
3115
3116 uint perc = 3; // Between 3% and 9% chance of creating a new industry.
3117 if ((_industry_builder.wanted_inds >> 16) > GetCurrentTotalNumberOfIndustries()) {
3118 perc = std::min(9u, perc + (_industry_builder.wanted_inds >> 16) - GetCurrentTotalNumberOfIndustries());
3119 }
3120 for (uint16_t j = 0; j < change_loop; j++) {
3121 if (Chance16(perc, 100)) {
3122 _industry_builder.TryBuildNewIndustry();
3123 } else {
3125 if (i != nullptr) {
3126 ChangeIndustryProduction(i, false);
3127 SetWindowDirty(WindowClass::IndustryView, i->index);
3128 }
3129 }
3130 }
3131
3132 /* production-change */
3133 InvalidateWindowData(WindowClass::IndustryDirectory, 0, IDIWD_PRODUCTION_CHANGE);
3134});
3135
3137static const IntervalTimer<TimerGameEconomy> _economy_industries_monthly({TimerGameEconomy::Trigger::Month, TimerGameEconomy::Priority::Industry}, [](auto)
3138{
3140
3141 _industry_builder.EconomyMonthlyLoop();
3142
3143 for (Industry *i : Industry::Iterate()) {
3145 if (i->prod_level == PRODLEVEL_CLOSURE) {
3146 delete i;
3147 } else {
3148 ChangeIndustryProduction(i, true);
3149 SetWindowDirty(WindowClass::IndustryView, i->index);
3150 }
3151 }
3152
3153 /* production-change */
3154 InvalidateWindowData(WindowClass::IndustryDirectory, 0, IDIWD_PRODUCTION_CHANGE);
3155});
3156
3157
3158void InitializeIndustries()
3159{
3160 Industry::industries.fill({});
3161 _industry_sound_tile = TileIndex{};
3162
3163 _industry_builder.Reset();
3164}
3165
3168{
3169 int count = 0;
3170 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
3171 if (Industry::GetIndustryTypeCount(it) > 0) continue; // Types of existing industries can be skipped.
3172
3173 bool force_at_least_one;
3174 uint32_t chance = GetScaledIndustryGenerationProbability(it, std::nullopt, &force_at_least_one);
3175 if (chance == 0 || !force_at_least_one) continue; // Types that are not available can be skipped.
3176
3177 const IndustrySpec *is = GetIndustrySpec(it);
3178 ShowErrorMessage(GetEncodedString(STR_ERROR_NO_SUITABLE_PLACES_FOR_INDUSTRIES, is->name),
3179 GetEncodedString(STR_ERROR_NO_SUITABLE_PLACES_FOR_INDUSTRIES_EXPLANATION), WarningLevel::Warning);
3180
3181 count++;
3182 if (count >= 3) break; // Don't swamp the user with errors.
3183 }
3184}
3185
3194
3200{
3201 /* Lumber mills are neither raw nor processing */
3202 return this->life_type.Test(IndustryLifeType::Processing) &&
3204}
3205
3211{
3212 /* Building raw industries like secondary uses different price base */
3213 return (_price[(_settings_game.construction.raw_industry_construction == 1 && this->IsRawIndustry()) ?
3214 Price::BuildIndustryRaw : Price::BuildIndustry] * this->cost_multiplier) >> 8;
3215}
3216
3224{
3226}
3227
3242
3244static CommandCost TerraformTile_Industry(TileIndex tile, DoCommandFlags flags, int z_new, Slope tileh_new)
3245{
3246 if (AutoslopeEnabled()) {
3247 /* We imitate here TTDP's behaviour:
3248 * - Both new and old slope must not be steep.
3249 * - TileMaxZ must not be changed.
3250 * - Allow autoslope by default.
3251 * - Disallow autoslope if callback succeeds and returns non-zero.
3252 */
3253 Slope tileh_old = GetTileSlope(tile);
3254 /* TileMaxZ must not be changed. Slopes must not be steep. */
3255 if (!IsSteepSlope(tileh_old) && !IsSteepSlope(tileh_new) && (GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new))) {
3256 const IndustryGfx gfx = GetIndustryGfx(tile);
3257 const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);
3258
3259 /* Call callback 3C 'disable autosloping for industry tiles'. */
3261 /* If the callback fails, allow autoslope. */
3262 uint16_t res = GetIndustryTileCallback(CBID_INDTILE_AUTOSLOPE, 0, 0, gfx, Industry::GetByTile(tile), tile);
3264 } else {
3265 /* allow autoslope */
3267 }
3268 }
3269 }
3270 return Command<Commands::LandscapeClear>::Do(flags, tile);
3271}
3272
3275 .draw_tile_proc = DrawTile_Industry,
3276 .get_slope_pixel_z_proc = [](TileIndex tile, uint, uint, bool) { return GetTileMaxPixelZ(tile); },
3277 .clear_tile_proc = ClearTile_Industry,
3278 .add_accepted_cargo_proc = AddAcceptedCargo_Industry,
3279 .get_tile_desc_proc = GetTileDesc_Industry,
3280 .click_tile_proc = ClickTile_Industry,
3281 .animate_tile_proc = AnimateTile_Industry,
3282 .tile_loop_proc = TileLoop_Industry,
3283 .change_tile_owner_proc = ChangeTileOwner_Industry,
3284 .get_foundation_proc = GetFoundation_Industry,
3285 .terraform_tile_proc = TerraformTile_Industry,
3286};
3287
3288bool IndustryCompare::operator() (const IndustryListEntry &lhs, const IndustryListEntry &rhs) const
3289{
3290 /* Compare by distance first and use index as a tiebreaker. */
3291 return std::tie(lhs.distance, lhs.industry->index) < std::tie(rhs.distance, rhs.industry->index);
3292}
3293
3299{
3300 auto ita = std::find_if(std::rbegin(ind->accepted), std::rend(ind->accepted), [](const auto &a) { return IsValidCargoType(a.cargo); });
3301 ind->accepted.erase(ita.base(), std::end(ind->accepted));
3302 ind->accepted.shrink_to_fit();
3303
3304 auto itp = std::find_if(std::rbegin(ind->produced), std::rend(ind->produced), [](const auto &p) { return IsValidCargoType(p.cargo); });
3305 ind->produced.erase(itp.base(), std::end(ind->produced));
3306 ind->produced.shrink_to_fit();
3307}
Base functions for all AIs.
void AddAnimatedTile(TileIndex tile, bool mark_dirty)
Add the given tile to the animated tile table (if it does not exist yet).
void DeleteAnimatedTile(TileIndex tile, bool immediate)
Stops animation on the given tile.
Tile animation!
Functions related to autoslope.
bool AutoslopeEnabled()
Tests if autoslope is enabled for _current_company.
Definition autoslope.h:65
Class for backupping variables and making sure they are restored later.
static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Map accessor functions for bridges.
bool IsBridgeAbove(Tile t)
checks if a bridge is set above the ground of this tile
Definition bridge_map.h:45
Tables with default industry layouts and behaviours.
static constexpr CargoType INVALID_CARGO
Invalid marker for cargoes.
Definition cargo_type.h:83
bool IsValidCargoType(CargoType cargo)
Test whether cargo type is not INVALID_CARGO.
Definition cargo_type.h:112
EnumBitSet< CargoType, uint64_t > CargoTypes
Bitset of CargoType elements.
Definition cargo_type.h:115
static constexpr CargoLabel CT_PASSENGERS
Cargo label for passengers.
Definition cargo_type.h:32
CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:22
CargoType GetCargoTypeByLabel(CargoLabel label)
Get cargo assigned to a label.
Definition cargotype.h:268
Cheats _cheats
All the cheats.
Definition cheat.cpp:16
Types related to cheating.
static void BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company=CompanyID::Invalid())
Broadcast a new event to all active AIs.
Definition ai_core.cpp:250
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr bool IsValid() const
Test that the raw value of this bit set is valid.
constexpr Timpl & Set()
Set all bits.
constexpr bool Any(const Timpl &other) const
Test if any of the given values are set.
Common return value for all commands.
bool Succeeded() const
Did this command succeed?
bool Failed() const
Did this command fail?
Container for an encoded string, created by GetEncodedString.
static void NewEvent(class ScriptEvent *event)
Queue a new event for the game script.
An interval timer will fire every interval, and will continue to fire until it is deleted.
Definition timer.h:76
uint16_t w
The width of the area.
void Add(TileIndex to_add)
Add a single tile to a tile area; enlarge if needed.
TileIndex tile
The base tile of the area.
uint16_t h
The height of the area.
OrthogonalTileArea & Expand(int rad)
Expand a tile area by rad tiles in each direction, keeping within map bounds.
Generate TileIndices around a center tile or tile area, with increasing distance.
static constexpr TimerGameTick::Ticks DAY_TICKS
1 day is 74 ticks; TimerGameCalendar::date_fract used to be uint16_t and incremented by 885.
static constexpr TimerGameTick::Ticks INDUSTRY_CUT_TREE_TICKS
Cycle duration for lumber mill's extra action.
static constexpr TimerGameTick::Ticks INDUSTRY_PRODUCE_TICKS
Cycle duration for industry production.
Wrapper class to abstract away the way the tiles are stored.
Definition map_func.h:25
static Date date
Current date in days (day counter).
static Year year
Current year, starting at 0.
static Year year
Current year, starting at 0.
static Month month
Current month (0..11).
static TickCounter counter
Monotonic counter, in ticks, since start of game.
Map accessors for 'clear' tiles.
bool IsClearGround(Tile t, ClearGround ct)
Set the type of clear tile.
Definition clear_map.h:65
void SetFence(Tile t, DiagDirection side, uint h)
Sets the type of fence (and whether there is one) for the given border.
Definition clear_map.h:234
IndustryID GetIndustryIndexOfField(Tile t)
Get the industry (farm) that made the field.
Definition clear_map.h:189
@ Desert
Desert with transition (1,3).
Definition clear_map.h:26
@ Fields
Farm fields (3).
Definition clear_map.h:25
@ Rough
Rough mounds (3).
Definition clear_map.h:23
ClearGround GetClearGround(Tile t)
Get the type of clear tile.
Definition clear_map.h:52
void SetIndustryIndexOfField(Tile t, IndustryID i)
Set the industry (farm) that made the field.
Definition clear_map.h:201
void MakeField(Tile t, uint field_type, IndustryID industry)
Make a (farm) field tile.
Definition clear_map.h:274
void SetClearCounter(Tile t, uint c)
Sets the counter used to advance to the next clear density/field type.
Definition clear_map.h:138
uint GetFence(Tile t, DiagDirection side)
Is there a fence at the given border?
Definition clear_map.h:215
bool IsSnowTile(Tile t)
Test if a tile is covered with snow.
Definition clear_map.h:40
CommandCost CommandCostWithParam(StringID str, uint64_t value)
Return an error status, with string and parameter.
Definition command.cpp:415
Functions related to commands.
CommandCost & ExtractCommandCost(Tret &ret)
Extract the CommandCost from a command proc result.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
@ Auto
don't allow building on structures
@ NoModifyTownRating
do not change town rating
@ NoWater
don't allow building on water
@ Execute
execute the given command
@ NoTestTownRating
town rating does not disallow you from building
EnumBitSet< DoCommandFlag, uint16_t > DoCommandFlags
Bitset of DoCommandFlag elements.
Definition of stuff that is very close to a company, like the company struct itself.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
CompanyID _current_company
Company currently doing an action.
bool IsLocalCompany()
Is the current company the local company?
static constexpr Owner OWNER_DEITY
The object is owned by a superuser / goal script.
static constexpr Owner OWNER_TOWN
A town owns the tile, or a town is expanding.
static constexpr Owner OWNER_NONE
The tile has no ownership.
static constexpr Owner INVALID_OWNER
An invalid owner.
static constexpr Owner OWNER_WATER
The tile/execution is done by "water".
DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
Axis OtherAxis(Axis a)
Select the other axis as provided.
Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
DiagDirection
Enumeration for diagonal directions.
@ SW
Southwest.
@ NW
Northwest.
@ NE
Northeast, upper right on your monitor.
@ SE
Southeast.
Prices _price
Prices and also the fractional part.
Definition economy.cpp:109
static uint ScaleByInverseCargoScale(uint num, bool town)
Scale a number by the inverse of the cargo scale setting, e.g.
bool EconomyIsInRecession()
Is the economy in recession?
uint ScaleByCargoScale(uint num, bool town)
Scale a number by the cargo scale setting.
@ Original
Imitates original TTD economy.
@ Frozen
Stops production changes and industry closures.
@ Smooth
Makes production changes more often, and in smaller steps.
@ Construction
Construction costs.
@ Other
Other expenses.
@ BuildIndustryRaw
Price for funding new raw industries, e.g. coal mine, forest.
@ BuildFoundation
Price for building foundation under other constructions e.g. roads, rails, depots,...
@ BuildIndustry
Price for funding new industries.
@ ClearIndustry
Price for destroying industries.
EffectVehicle * CreateEffectVehicle(int x, int y, int z, EffectVehicleType type)
Create an effect vehicle at a particular location.
EffectVehicle * CreateEffectVehicleAbove(int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular location.
Base class for all effect vehicles.
Functions related to effect vehicles.
@ EV_BUBBLE
Bubble of bubble generator (industry).
@ EV_CHIMNEY_SMOKE
Smoke of power plant (industry).
@ EV_COPPER_MINE_SMOKE
Smoke at copper mine.
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23).
Definition enum_type.hpp:21
EnumClassIndexContainer< std::array< T, to_underlying(N)>, Index > EnumIndexArray
A typedef for EnumClassIndexContainer using std::array as the backing container type.
Functions related to errors.
@ Warning
Other information.
Definition error.h:23
@ Info
Used for DoCommand-like (and some non-fatal AI GUI) errors/information.
Definition error.h:22
void ShowErrorMessage(EncodedString &&summary_msg, int x, int y, CommandCost &cc)
Display an error message in a window.
Base functions for all Games.
bool _generating_world
Whether we are generating the map or not.
Definition genworld.cpp:70
Functions related to world/map generation.
void IncreaseGeneratingWorldProgress(GenWorldProgress cls)
Increases the current stage of the world generation with one.
@ LG_TERRAGENESIS
TerraGenesis Perlin landscape generator.
Definition genworld.h:20
@ WaterIndustries
Generate industries.
Definition genworld.h:64
@ LandIndustries
Generate industries.
Definition genworld.h:63
void SetGeneratingWorldProgress(GenWorldProgress cls, uint total)
Set the total of a stage of the world generation.
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:17
Colours
One of 16 base colours used for companies and windows/widgets.
Definition gfx_type.h:283
uint8_t GetSnowLine()
Get the current snow line, either variable or static.
uint8_t HighestSnowLine()
Get the highest possible snow line height, either variable or static.
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
void UpdateValidHistory(ValidHistoryMask &valid_history, const HistoryRange &hr, uint cur_month)
Update mask of valid records for a historical data.
Definition history.cpp:25
Functions for storing historical data.
T GetAndResetAccumulatedAverage(Taccrued &total)
Get an average value for the previous month, as reset for the next month.
void RotateHistory(HistoryData< T > &history, ValidHistoryMask valid_history, const HistoryRange &hr, uint cur_month)
Rotate historical data.
Types for storing historical data.
Base of all industries.
static constexpr uint8_t PRODLEVEL_MAXIMUM
the industry is running at full speed
Definition industry.h:38
void ReleaseDisastersTargetingIndustry(IndustryID)
Marks all disasters targeting this industry in such a way they won't call Industry::Get(v->dest_tile)...
static constexpr uint8_t PRODLEVEL_DEFAULT
default level set when the industry is created
Definition industry.h:37
static const TimerGameEconomy::Year PROCESSING_INDUSTRY_ABANDONMENT_YEARS
If a processing industry doesn't produce for this many consecutive economy years, it may close.
Definition industry.h:28
IndustryBuildData _industry_builder
In-game manager of industries.
EnumBitSet< IndustryControlFlag, uint8_t, IndustryControlFlag::End > IndustryControlFlags
Bitset of IndustryControlFlag elements.
Definition industry.h:59
static constexpr uint8_t PRODLEVEL_MINIMUM
below this level, the industry is set to be closing
Definition industry.h:36
static constexpr uint8_t PRODLEVEL_CLOSURE
signal set to actually close the industry
Definition industry.h:35
@ ExternalProdLevel
Indicates that the production level of the industry is externally controlled.
Definition industry.h:54
@ NoClosure
Industry can not close regardless of production level or time since last delivery.
Definition industry.h:52
@ NoProductionDecrease
When industry production change is evaluated, rolls to decrease are ignored.
Definition industry.h:46
@ NoProductionIncrease
When industry production change is evaluated, rolls to increase are ignored.
Definition industry.h:48
static bool ClickTile_Industry(TileIndex tile)
Tile callback function signature for clicking a tile.
const TileTypeProcs _tile_type_industry_procs
TileTypeProcs definitions for TileType::Industry tiles.
Definition landscape.cpp:62
static uint16_t GetIndustryGamePlayProbability(IndustryType it, uint8_t *min_number)
Compute the probability for constructing a new industry during game play.
static void TileLoop_Industry(TileIndex tile)
Tile callback function signature for running periodic tile updates.
static CommandCost CheckNewIndustry_Water(TileIndex tile)
Check the conditions of IndustryCheck::Water (Industry should be in the desert).
static CommandCost CheckNewIndustry_None(TileIndex)
Check the conditions of IndustryCheck::None (Always succeeds).
static CommandCost CheckIfIndustryIsAllowed(TileIndex tile, IndustryType type, const Town *t)
Is the industry allowed to be built at this place for the town?
const IndustrySpec * GetIndustrySpec(IndustryType thistype)
Accessor for array _industry_specs.
static bool TransportIndustryGoods(TileIndex tile)
Move produced cargo from industry to nearby stations.
CommandCost CmdIndustrySetExclusivity(DoCommandFlags flags, IndustryID ind_id, Owner company_id, bool consumer)
Change exclusive consumer or supplier for the industry.
static CommandCost CheckIfIndustryTileSlopes(TileIndex tile, const IndustryTileLayout &layout, size_t layout_index, IndustryType type, uint16_t initial_random_bits, Owner founder, IndustryAvailabilityCallType creation_type, bool *custom_shape_check=nullptr)
Check slope requirements for industry tiles.
static IndustryGenerationProbabilities GetScaledProbabilities(bool water)
Get scaled industry generation probabilities.
static uint GetCurrentTotalNumberOfIndustries()
Get total number of industries existing in the game.
static CommandCost CheckNewIndustry_OilRefinery(TileIndex tile)
Check the conditions of IndustryCheck::Refinery (Industry should be positioned near edge of the map).
static CommandCost CheckIfIndustryTilesAreFree(TileIndex tile, const IndustryTileLayout &layout, IndustryType type)
Are the tiles of the industry free?
CommandCost CmdIndustrySetProduction(DoCommandFlags flags, IndustryID ind_id, uint8_t prod_level, bool show_news, const EncodedString &custom_news)
Set industry production.
static bool CheckIfCanLevelIndustryPlatform(TileIndex tile, DoCommandFlags flags, const IndustryTileLayout &layout)
This function tries to flatten out the land below an industry, without damaging the surroundings too ...
static CommandCost CheckNewIndustry_BubbleGen(TileIndex tile)
Check the conditions of IndustryCheck::BubbleGen (Industry should be in low land).
static CommandCost CheckNewIndustry_Farm(TileIndex tile)
Check the conditions of IndustryCheck::Farm (Industry should be below snow-line in arctic).
static void AdvertiseIndustryOpening(const Industry *ind)
Advertise about a new industry opening.
static void ChopLumberMillTrees(Industry *i)
Perform a circular search around the Lumber Mill in order to find trees to cut.
static uint32_t GetScaledIndustryGenerationProbability(IndustryType it, std::optional< bool > water, bool *force_at_least_one)
Compute the appearance probability for an industry during map creation.
static bool CheckScaledDistanceFromEdge(TileIndex tile, uint maxdist)
Check if a tile is within a distance from map edges, scaled by map dimensions independently.
static void ReportNewsProductionChangeIndustry(Industry *ind, CargoType cargo, int percent)
Report news that industry production has changed significantly.
static void GetTileDesc_Industry(TileIndex tile, TileDesc &td)
Tile callback function signature for obtaining a tile description.
bool IsTileForestIndustry(TileIndex tile)
Check whether the tile is a forest.
const IndustryTileSpec * GetIndustryTileSpec(IndustryGfx gfx)
Accessor for array _industry_tile_specs.
static void CanCargoServiceIndustry(CargoType cargo, Industry *ind, bool *c_accepts, bool *c_produces)
Can given cargo type be accepted or produced by the industry?
static Foundation GetFoundation_Industry(TileIndex tile, Slope tileh)
Tile callback function signature for getting the foundation of a tile.
void GenerateIndustries()
This function will create random industries during game creation.
static void ProduceIndustryGoodsHelper(Industry *i, bool scale)
Helper for ProduceIndustryGoods that scales and produces cargos.
static void ChangeTileOwner_Industry(TileIndex tile, Owner old_owner, Owner new_owner)
Tile callback function signature for changing the owner of a tile.
static Industry * PlaceIndustry(IndustryType type, IndustryAvailabilityCallType creation_type, bool try_hard)
Try to place the industry in the game.
static bool IsSuitableForFarmField(TileIndex tile, bool allow_fields, bool allow_rough)
Check whether the tile can be replaced by a farm field.
static CommandCost CheckNewIndustry_Plantation(TileIndex tile)
Check the conditions of IndustryCheck::Plantation (Industry should NOT be in the desert).
void CheckIndustries()
Verify whether the generated industries are complete, and warn the user if not.
static void PopulateStationsNearby(Industry *ind)
Populate an industry's list of nearby stations, and if it accepts any cargo, also add the industry to...
static CommandCost CheckNewIndustry_Forest(TileIndex tile)
Check the conditions of IndustryCheck::Forest (Industry should be build above snow-line in arctic cli...
static void DoCreateNewIndustry(Industry *i, TileIndex tile, IndustryType type, const IndustryTileLayout &layout, size_t layout_index, Town *t, Owner founder, uint16_t initial_random_bits)
Put an industry on the map.
CommandCost CheckNewIndustryProc(TileIndex tile)
Industrytype check function signature.
static CommandCost CreateNewIndustryHelper(TileIndex tile, IndustryType type, DoCommandFlags flags, const IndustrySpec *indspec, size_t layout_index, uint32_t random_var8f, uint16_t random_initial_bits, Owner founder, IndustryAvailabilityCallType creation_type, Industry **ip)
Helper function for Build/Fund an industry.
static int WhoCanServiceIndustry(Industry *ind)
Compute who can service the industry.
void ResetIndustries()
This function initialize the spec arrays of both industry and industry tiles.
static CommandCost CheckIfFarEnoughFromConflictingIndustry(TileIndex tile, IndustryType type)
Check that the new industry is far enough from conflicting industries.
static CommandCost CheckNewIndustry_OilRig(TileIndex tile)
Check the conditions of IndustryCheck::OilRig (Industries at sea should be positioned near edge of th...
void TrimIndustryAcceptedProduced(Industry *ind)
Remove unused industry accepted/produced slots – entries after the last slot with valid cargo.
static uint GetNumberOfIndustries()
Get wanted number of industries on the map.
static void AddAcceptedCargo_Industry(TileIndex tile, CargoArray &acceptance, CargoTypes &always_accepted)
Tile callback function signature for obtaining cargo acceptance of a tile.
CommandCost CmdBuildIndustry(DoCommandFlags flags, TileIndex tile, IndustryType it, uint32_t first_layout, bool fund, uint32_t seed)
Build/Fund an industry.
static CommandCost ClearTile_Industry(TileIndex tile, DoCommandFlags flags)
Tile callback function signature for clearing a tile.
static void PlaceInitialIndustry(IndustryType type, bool water, bool try_hard)
Try to build a industry on the map.
static bool CheckIndustryCloseDownProtection(IndustryType type)
Protects an industry from closure if the appropriate flags and conditions are met CanCloseLastInstanc...
static CommandCost TerraformTile_Industry(TileIndex tile, DoCommandFlags flags, int z_new, Slope tileh_new)
Tile callback function signature of the terraforming callback.
static void AnimateTile_Industry(TileIndex tile)
Tile callback function signature for animating a tile.
static void DrawTile_Industry(TileInfo *ti)
Tile callback function signature for drawing a tile and its contents to the screen.
static void SetupFarmFieldFence(TileIndex tile, int size, uint8_t type, DiagDirection side)
Build farm field fence.
static constexpr EnumIndexArray< CheckNewIndustryProc *const, IndustryCheck, IndustryCheck::End > _check_new_industry_procs
Check functions for different types of industry.
static const IntervalTimer< TimerGameEconomy > _economy_industries_daily({TimerGameEconomy::Trigger::Day, TimerGameEconomy::Priority::Industry}, [](auto) { _economy.industry_daily_change_counter+=_economy.industry_daily_increment;uint16_t change_loop=_economy.industry_daily_change_counter > > 16;_economy.industry_daily_change_counter &=0xFFFF;if(change_loop==0) { return;} AutoRestoreBackup cur_company(_current_company, OWNER_NONE);uint perc=3;if((_industry_builder.wanted_inds > > 16) > GetCurrentTotalNumberOfIndustries()) { perc=std::min(9u, perc+(_industry_builder.wanted_inds > > 16) - GetCurrentTotalNumberOfIndustries());} for(uint16_t j=0;j< change_loop;j++) { if(Chance16(perc, 100)) { _industry_builder.TryBuildNewIndustry();} else { Industry *i=Industry::GetRandom();if(i !=nullptr) { ChangeIndustryProduction(i, false);SetWindowDirty(WindowClass::IndustryView, i->index);} } } InvalidateWindowData(WindowClass::IndustryDirectory, 0, IDIWD_PRODUCTION_CHANGE);})
Every economy day handler for the industry changes Taking the original map size of 256*256,...
CommandCost CmdIndustrySetFlags(DoCommandFlags flags, IndustryID ind_id, IndustryControlFlags ctlflags)
Set industry control flags.
IndustryType GetIndustryType(Tile tile)
Retrieve the type for this industry.
static const IntervalTimer< TimerGameEconomy > _economy_industries_monthly({TimerGameEconomy::Trigger::Month, TimerGameEconomy::Priority::Industry}, [](auto) { AutoRestoreBackup cur_company(_current_company, OWNER_NONE);_industry_builder.EconomyMonthlyLoop();for(Industry *i :Industry::Iterate()) { UpdateIndustryStatistics(i);if(i->prod_level==PRODLEVEL_CLOSURE) { delete i;} else { ChangeIndustryProduction(i, true);SetWindowDirty(WindowClass::IndustryView, i->index);} } InvalidateWindowData(WindowClass::IndustryDirectory, 0, IDIWD_PRODUCTION_CHANGE);})
Economy monthly loop for industries.
static void UpdateIndustryStatistics(Industry *i)
Monthly update of industry statistics.
static CommandCost FindTownForIndustry(TileIndex tile, IndustryType type, Town **t)
Find a town for the industry, while checking for multiple industries in the same town.
static Industry * CreateNewIndustry(TileIndex tile, IndustryType type, IndustryAvailabilityCallType creation_type)
Create a new industry of random layout.
static void ChangeIndustryProduction(Industry *i, bool monthly)
Change industry production or do closure.
static CommandCost CheckNewIndustry_Lumbermill(TileIndex tile)
Check the conditions of IndustryCheck::Lumbermill (Industry should be in the rainforest).
CommandCost CmdIndustrySetText(DoCommandFlags flags, IndustryID ind_id, const EncodedString &text)
Change additional industry text.
Command definitions related to industries.
Information about the behaviour of the default industry tiles.
static const uint8_t _industry_anim_offs_toffee[]
This is ONLY used for Toffee Quarry.
static const Coord2D< uint8_t > _drawtile_proc1[5]
This is ONLY used for Sugar Mine.
static const DrawIndustryAnimationStruct _draw_industry_spec1[96]
This is ONLY used for Sugar Mine.
static const Coord2D< uint8_t > _coal_plant_sparks[]
Movement of the sparks , only used for Power Station.
static const uint8_t _industry_anim_offs_bubbles[]
This is ONLY used for the Bubble Generator.
static const DrawBuildingsTileStruct _industry_draw_tile_data[NEW_INDUSTRYTILEOFFSET *4]
Structure for industry tiles drawing.
void SetIndustryCompleted(Tile tile)
Set if the industry that owns the tile as under construction or not.
void SetIndustryGfx(Tile t, IndustryGfx gfx)
Set the industry graphics ID for the given industry tile.
void ResetIndustryConstructionStage(Tile tile)
Reset the construction stage counter of the industry, as well as the completion bit.
void SetIndustryConstructionCounter(Tile tile, uint8_t value)
Sets this industry tile's construction counter value.
IndustryGfx GetIndustryGfx(Tile t)
Get the industry graphics ID for the given industry tile.
bool IsIndustryCompleted(Tile t)
Is this industry tile fully built?
IndustryID GetIndustryIndex(Tile t)
Get the industry ID of the given tile.
uint8_t GetIndustryConstructionCounter(Tile tile)
Returns this industry tile's construction counter value.
void MakeIndustry(Tile t, IndustryID index, IndustryGfx gfx, uint8_t random, WaterClass wc)
Make the given tile an industry tile.
void SetIndustryAnimationLoop(Tile tile, uint8_t count)
Set the animation loop number.
void SetIndustryConstructionStage(Tile tile, uint8_t value)
Sets the industry construction stage of the specified tile.
uint8_t GetIndustryAnimationLoop(Tile tile)
Get the animation loop number.
uint8_t GetIndustryConstructionStage(Tile tile)
Returns the industry construction stage of the specified tile.
static const IndustryGfx NEW_INDUSTRYTILEOFFSET
original number of tiles
static constexpr IndustryGfx GFX_COPPER_MINE_TOWER_NOT_ANIMATED
static const IndustryGfx INDUSTRYTILE_NOANIM
Sentinel value to mark industry tiles as having no animation.
@ IndustryTick
The industry has been triggered via its tick.
@ TileLoop
The tile of the industry has been triggered during the tileloop.
static constexpr IndustryGfx GFX_GOLD_MINE_TOWER_ANIMATED
static const int INDUSTRY_ORIGINAL_NUM_INPUTS
Original number of accepted cargo types.
static constexpr IndustryGfx GFX_WATERTILE_SPECIALCHECK
Sentinel marker in industry layout to perform a water tile check.
static const int INDUSTRY_NUM_OUTPUTS
Number of cargo types an industry can produce.
static constexpr IndustryGfx GFX_TOFFEE_QUARRY
static constexpr IndustryGfx GFX_SUGAR_MINE_SIEVE
static const int INDUSTRY_NUM_INPUTS
Number of cargo types an industry can accept.
static constexpr IndustryGfx GFX_PLASTIC_FOUNTAIN_ANIMATED_5
static constexpr IndustryGfx GFX_POWERPLANT_CHIMNEY
static constexpr IndustryGfx GFX_OILWELL_ANIMATED_1
static constexpr IndustryGfx GFX_POWERPLANT_SPARKS
static constexpr IndustryGfx GFX_COAL_MINE_TOWER_NOT_ANIMATED
static constexpr IndustryGfx GFX_PLASTIC_FOUNTAIN_ANIMATED_4
static constexpr IndustryGfx GFX_OILWELL_ANIMATED_2
static constexpr IndustryGfx GFX_PLASTIC_FOUNTAIN_ANIMATED_3
static constexpr IndustryGfx GFX_COPPER_MINE_CHIMNEY
static constexpr IndustryGfx GFX_TOY_FACTORY
static const IndustryType NUM_INDUSTRYTYPES
total number of industry types, new and old; limited to 240 because we need some special ids like IT_...
static constexpr IndustryGfx GFX_COPPER_MINE_TOWER_ANIMATED
static constexpr IndustryGfx GFX_BUBBLE_GENERATOR
static constexpr IndustryGfx GFX_PLASTIC_FOUNTAIN_ANIMATED_8
static const IndustryGfx INVALID_INDUSTRYTILE
one above amount is considered invalid
static constexpr IndustryGfx GFX_COAL_MINE_TOWER_ANIMATED
static constexpr IndustryGfx GFX_OILWELL_NOT_ANIMATED
static constexpr IndustryGfx GFX_BUBBLE_CATCHER
static constexpr IndustryGfx GFX_PLASTIC_FOUNTAIN_ANIMATED_6
static constexpr IndustryGfx GFX_PLASTIC_FOUNTAIN_ANIMATED_1
@ CargoDistributed
Trigger when cargo is distributed.
@ IndustryTick
Trigger every tick.
@ TileLoop
Trigger in the periodic tile loop.
static constexpr IndustryGfx GFX_PLASTIC_FOUNTAIN_ANIMATED_7
static const IndustryGfx NUM_INDUSTRYTILES
total number of industry tiles, new and old
static constexpr IndustryGfx GFX_PLASTIC_FOUNTAIN_ANIMATED_2
static constexpr IndustryGfx GFX_OILRIG_1
static const int INDUSTRY_COMPLETED
final stage of industry construction.
static constexpr IndustryGfx GFX_GOLD_MINE_TOWER_NOT_ANIMATED
static constexpr IndustryGfx GFX_OILWELL_ANIMATED_3
@ NoBuildMapCreation
Do not force one instance of this type to appear on map generation.
@ CutTrees
cuts trees and produce first output cargo from them (lumber mill)
@ PlantOnBuild
Fields are planted around when built (all farms).
@ Before1950
can only be built before 1950 (oil wells)
@ BuiltOnWater
is built on water (oil rig)
@ DontIncrProd
do not increase production (oil wells) in the temperate climate
@ CargoTypesUnlimited
Allow produced/accepted cargoes callbacks to supply more than 2 and 3 types.
@ After1960
can only be built after 1960 (oil rigs)
@ PlantFields
periodically plants fields around itself (temp and arctic farms)
@ Town1200More
can only be built in towns larger than 1200 inhabitants (temperate bank)
@ NoPaxProdClamp
Do not clamp production of passengers. (smooth economy only).
@ CanCloseLastInstance
Allow closing down the last instance of this type.
@ OnlyNearTown
is always built near towns (toy shop)
@ AcceptsAllCargo
Tile always accepts all cargoes the associated industry accepts.
@ Processing
Like factories.
@ Organic
Like forests.
@ Extractive
Like mines.
IndustryGfx GetTranslatedIndustryTileID(IndustryGfx gfx)
Do industry gfx ID translation for NewGRFs.
std::vector< IndustryTileLayoutTile > IndustryTileLayout
A complete tile layout for an industry is a list of tiles.
EnumBitSet< IndustryBehaviour, uint32_t > IndustryBehaviours
Bitset of IndustryBehaviour elements.
@ Gameplay
either by user or random creation process
@ ScenarioEditor
while editing a scenario
@ MapGeneration
during random map creation
@ OilRig
Industries at sea should be positioned near edge of the map.
@ Refinery
Industry should be positioned near edge of the map.
static constexpr IndustryLifeTypes INDUSTRYLIFE_BLACK_HOLE
Like power plants and banks.
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
Functions related to OTTD's landscape.
Command definitions related to landscape (slopes etc.).
@ Arctic
Landscape with snow levels.
@ Tropic
Landscape with distinct rainforests and deserts,.
@ Temperate
Base landscape.
uint DistanceMax(TileIndex t0, TileIndex t1)
Gets the biggest distance component (x or y) between the two given tiles.
Definition map.cpp:200
uint DistanceFromEdgeDir(TileIndex tile, DiagDirection dir)
Gets the distance to the edge of the map in given direction.
Definition map.cpp:245
TileIndex TileAddWrap(TileIndex tile, int addx, int addy)
This function checks if we add addx/addy to tile, if we do wrap around the edges.
Definition map.cpp:119
Functions related to maps.
TileIndex TileAddXY(TileIndex tile, int x, int y)
Adds a given offset to a tile.
Definition map_func.h:474
TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
Return the offset between two tiles from a TileIndexDiffC struct.
Definition map_func.h:444
TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition map_func.h:392
TileIndexDiff TileOffsByAxis(Axis axis)
Convert an Axis to a TileIndexDiff.
Definition map_func.h:559
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:429
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:419
#define RandomTile()
Get a valid random tile.
Definition map_func.h:656
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition map_func.h:574
int32_t TileIndexDiff
An offset value between two tiles.
Definition map_type.h:23
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition math_func.hpp:23
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
constexpr T Delta(const T a, const T b)
Returns the (absolute) difference between two (scalar) variables.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition math_func.hpp:79
constexpr uint ClampU(const uint a, const uint min, const uint max)
Clamp an unsigned integer between an interval.
constexpr To ClampTo(From value)
Clamp the given value down to lie within the requested type.
StringID MapGRFStringID(GrfID grfid, GRFStringID str)
Used when setting an object's property to map to the GRF's strings while taking in consideration the ...
@ IndustryTiles
Industry tiles feature.
Definition newgrf.h:91
@ Industries
Industries feature.
Definition newgrf.h:92
const IndustrySpec _origin_industry_specs[NEW_INDUSTRYOFFSET]
Extern declaration for _origin_industry_specs in table/build_industry.h.
@ NoAnimation
There is no animation.
@ InputCargoTypes
customize the cargoes the industry requires
@ ProductionChange
controls random production change
@ DecideColour
give a custom colour to newly build industries
@ SpecialEffect
control special effects
@ ProdChangeBuild
initialise production level on construction
@ Production256Ticks
call production callback every 256 ticks
@ Location
check industry construction on given area
@ MonthlyProdChange
controls monthly random production change
@ ProductionCargoArrival
call production callback when cargo arrives at the industry
@ OutputCargoTypes
customize the cargoes the industry produces
@ CBID_INDUSTRY_OUTPUT_CARGO_TYPES
Customize the output cargo types of a newly build industry.
@ CBID_INDUSTRY_SPECIAL_EFFECT
Called to determine industry special effects.
@ CBID_INDTILE_AUTOSLOPE
Called to determine if industry can alter the ground below industry tile.
@ CBID_INDUSTRY_DECIDE_COLOUR
Called to determine the colour of an industry.
@ CBID_INDTILE_DRAW_FOUNDATIONS
Called to determine the type (if any) of foundation to draw for industry tile.
@ CBID_INDUSTRY_PRODUCTION_CHANGE
Called on production changes, so it can be adjusted.
@ CBID_INDUSTRY_MONTHLYPROD_CHANGE
Called monthly on production changes, so it can be adjusted more frequently.
@ CBID_INDUSTRY_PROD_CHANGE_BUILD
Called when industry is built to set initial production level.
@ CBID_INDTILE_CARGO_ACCEPTANCE
Called to query the cargo acceptance of the industry tile.
@ CBID_INDTILE_ACCEPT_CARGO
Called to determine which cargoes an industry should accept.
@ CBID_INDUSTRY_INPUT_CARGO_TYPES
Customize the input cargo types of a newly build industry.
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
@ ShapeCheck
decides slope suitability
@ AcceptCargo
decides accepted types
@ CargoAcceptance
decides amount of cargo acceptance
@ DrawFoundations
decides if default foundations need to be drawn
@ Autoslope
decides allowance of autosloping
CargoType GetCargoTranslation(uint8_t cargo, const GRFFile *grffile, bool usebit)
Translate a GRF-local cargo slot/bitnum into a CargoType.
Cargo support for NewGRFs.
bool ConvertBooleanCallback(const GRFFile *grffile, uint16_t cbid, uint16_t cb_res)
Converts a callback result into a boolean.
void ErrorUnknownCallbackResult(GrfID grfid, uint16_t cbid, uint16_t cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
GRFConfig * GetGRFConfig(GrfID grfid, uint32_t mask)
Retrieve a NewGRF from the current config by its grfid.
Functions/types related to NewGRF debugging.
void DeleteNewGRFInspectWindow(GrfSpecFeature feature, uint index)
Delete inspect window for a given feature and index.
CommandCost CheckIfCallBackAllowsCreation(TileIndex tile, IndustryType type, size_t layout, uint32_t seed, uint16_t initial_random_bits, Owner founder, IndustryAvailabilityCallType creation_type)
Check that the industry callback allows creation of the industry.
uint16_t GetIndustryCallback(CallbackID callback, uint32_t param1, uint32_t param2, Industry *industry, IndustryType type, TileIndex tile, std::span< int32_t > regs100)
Perform an industry callback.
void IndustryProductionCallback(Industry *ind, int reason)
Get the industry production callback and apply it to the industry.
uint32_t GetIndustryProbabilityCallback(IndustryType type, IndustryAvailabilityCallType creation_type, uint32_t default_prob)
Check with callback CBID_INDUSTRY_PROBABILITY whether the industry can be built.
bool IndustryTemporarilyRefusesCargo(Industry *ind, CargoType cargo_type)
Check whether an industry temporarily refuses to accept a certain cargo.
IndustryAvailabilityCallType
From where has callback CBID_INDUSTRY_PROBABILITY been called.
@ UserCreation
from the Fund/build window
@ MapGeneration
during random map generation
@ ProspectCreation
from the Fund/build using prospecting
@ RandomCreation
during creation of random ingame industry
void TriggerIndustryTileRandomisation(TileIndex tile, IndustryRandomTrigger trigger)
Trigger a random trigger for a single industry tile.
CommandCost PerformIndustryTileSlopeCheck(TileIndex ind_base_tile, TileIndex ind_tile, const IndustryTileSpec *its, IndustryType type, IndustryGfx gfx, size_t layout_index, uint16_t initial_random_bits, Owner founder, IndustryAvailabilityCallType creation_type)
Check the slope of a tile of a new industry.
void TriggerIndustryRandomisation(Industry *ind, IndustryRandomTrigger trigger)
Trigger a random trigger for all industry tiles.
NewGRF handling of industry tiles.
StrongType::Typedef< uint32_t, struct GRFStringIDTag, StrongType::Compare, StrongType::Integer > GRFStringID
Type for GRF-internal string IDs.
Functions related to news.
void DeleteIndustryNews(IndustryID iid)
Remove news regarding given industry.
NewsType
Type of news.
Definition news_type.h:30
@ IndustryCloseCompany
Closing of industries serviced by local company.
Definition news_type.h:37
@ IndustryCompany
Production changes of industry serviced by local company.
Definition news_type.h:41
@ IndustryOpen
Opening of industries.
Definition news_type.h:36
@ IndustryNobody
Other industry production changes.
Definition news_type.h:43
@ IndustryOther
Production changes of industry serviced by competitor(s).
Definition news_type.h:42
@ IndustryCloseNobody
Other industry closing.
Definition news_type.h:39
@ IndustryCloseOther
Closing of industries serviced by competitor(s).
Definition news_type.h:38
Base for all objects.
@ Editor
In the scenario editor.
Definition openttd.h:21
@ Transfer
Transfer all cargo onto the platform.
Definition order_type.h:70
@ Unload
Force unloading all cargo onto the platform, possibly not getting paid.
Definition order_type.h:69
Some methods of Pool are placed here in order to reduce compilation time and binary size.
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
uint32_t RandomRange(uint32_t limit, const std::source_location location=std::source_location::current())
Pick a random number between 0 and limit - 1, inclusive.
bool Chance16I(const uint32_t a, const uint32_t b, const uint32_t r)
Checks if a given randomize-number is below a given probability.
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.
bool Chance16R(const uint32_t a, const uint32_t b, uint32_t &r, const std::source_location location=std::source_location::current())
Flips a coin with a given probability and saves the randomize-number in a variable.
A number of safeguards to prevent using unsafe methods.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:61
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:60
IndustryDensity
Available industry map generation densities.
@ FundedOnly
The game does not build industries.
@ End
Number of industry density settings.
@ VeryLow
Very few industries at game start.
@ Custom
Custom number of industries.
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:170
static constexpr bool IsSteepSlope(Slope s)
Checks if a slope is steep.
Definition slope_func.h:36
Foundation FlatteningFoundation(Slope s)
Returns the foundation needed to flatten a slope.
Definition slope_func.h:377
Slope ComplementSlope(Slope s)
Return the complement of a slope.
Definition slope_func.h:86
Slope
Enumeration for the slope-type.
Definition slope_type.h:53
@ SLOPE_W
the west corner of the tile is raised
Definition slope_type.h:55
@ SLOPE_E
the east corner of the tile is raised
Definition slope_type.h:57
@ SLOPE_S
the south corner of the tile is raised
Definition slope_type.h:56
@ SLOPE_N
the north corner of the tile is raised
Definition slope_type.h:58
@ SLOPE_SW
south and west corner are raised
Definition slope_type.h:61
@ SLOPE_FLAT
a flat tile
Definition slope_type.h:54
@ SLOPE_NE
north and east corner are raised
Definition slope_type.h:63
@ SLOPE_SE
south and east corner are raised
Definition slope_type.h:62
@ SLOPE_NW
north and west corner are raised
Definition slope_type.h:60
Foundation
Enumeration for Foundations.
Definition slope_type.h:119
@ Leveled
The tile is leveled up to a flat slope.
Definition slope_type.h:121
@ None
The tile has no foundation, the slope remains unchanged.
Definition slope_type.h:120
Functions related to sound.
SoundFx
Sound effects from baseset.
Definition sound_type.h:45
@ SND_30_TOFFEE_QUARRY
48 == 0x30 Industry animation: toffee quarry: drill
Definition sound_type.h:95
@ SND_2E_BUBBLE_GENERATOR
46 == 0x2E Industry animation: bubble generator (1): generate bubble
Definition sound_type.h:93
@ SND_2D_SUGAR_MINE_1
45 == 0x2D Industry animation: sugar mine (1): shaking sieve
Definition sound_type.h:92
@ SND_2B_TOY_FACTORY_2
43 == 0x2B Industry animation: toy factory (2): stamp product
Definition sound_type.h:90
@ SND_38_LUMBER_MILL_1
56 == 0x38 Industry animation: lumber mill (1): chainsaw
Definition sound_type.h:103
@ SND_29_SUGAR_MINE_2
41 == 0x29 Industry animation: sugar mine (2): shaking sieve
Definition sound_type.h:88
@ SND_2C_TOY_FACTORY_1
44 == 0x2C Industry animation: toy factory (1): conveyor belt
Definition sound_type.h:91
@ SND_37_LUMBER_MILL_2
55 == 0x37 Industry animation: lumber mill (2): falling tree
Definition sound_type.h:102
@ SND_0C_POWER_STATION
10 == 0x0A Industry animation: power station: spark
Definition sound_type.h:57
@ SND_0B_MINE
9 == 0x09 Industry animation: coal/copper/gold mine: headgear
Definition sound_type.h:56
@ SND_36_LUMBER_MILL_3
54 == 0x36 Industry animation: lumber mill (3): crashing tree
Definition sound_type.h:101
@ SND_2A_TOY_FACTORY_3
42 == 0x2A Industry animation: toy factory (3): eject product
Definition sound_type.h:89
@ Industry
Source/destination is an industry.
Definition source_type.h:21
static PaletteID GetColourPalette(Colours colour)
Get recolour palette for a colour.
Definition sprite.h:221
PaletteID SpriteLayoutPaletteTransform(SpriteID image, PaletteID pal, PaletteID default_pal)
Applies PALETTE_MODIFIER_TRANSPARENT and PALETTE_MODIFIER_COLOUR to a palette entry of a sprite layou...
Definition sprite.h:188
PaletteID GroundSpritePaletteTransform(SpriteID image, PaletteID pal, PaletteID default_pal)
Applies PALETTE_MODIFIER_COLOUR to a palette entry of a ground sprite.
Definition sprite.h:207
static const SpriteID SPR_IT_TOY_FACTORY_STAMP_HOLDER
Definition sprites.h:1311
static const SpriteID SPR_IT_TOY_FACTORY_ROBOT
Definition sprites.h:1314
static const SpriteID SPR_IT_TOY_FACTORY_CLAY
Definition sprites.h:1313
static const SpriteID SPR_IT_POWER_PLANT_TRANSFORMERS
Definition sprites.h:1315
static const SpriteID SPR_IT_BUBBLE_GENERATOR_SPRING
Definition sprites.h:1309
static const SpriteID SPR_IT_SUGAR_MINE_PILE
Definition sprites.h:1306
static const SpriteID SPR_FLAT_WATER_TILE
Definition sprites.h:685
static const SpriteID SPR_IT_BUBBLE_GENERATOR_BUBBLE
Definition sprites.h:1310
static const SpriteID SPR_IT_TOFFEE_QUARRY_TOFFEE
Definition sprites.h:1307
static const SpriteID SPR_IT_TOFFEE_QUARRY_SHOVEL
Definition sprites.h:1308
static const SpriteID SPR_IT_SUGAR_MINE_SIEVE
Definition sprites.h:1304
static const SpriteID SPR_IT_SUGAR_MINE_CLOUDS
Definition sprites.h:1305
static const SpriteID SPR_IT_TOY_FACTORY_STAMP
Definition sprites.h:1312
Base classes/functions for stations.
void ForAllStationsAroundTiles(const TileArea &ta, Func func)
Call a function on all stations that have any part of the requested area within their catchment.
void ClearDockingTilesCheckingNeighbours(TileIndex tile)
Clear docking tile status from tiles around a removed dock, if the tile has no neighbours which would...
Functions related to stations.
bool IsOilRig(Tile t)
Is tile t part of an oilrig?
Definition of base types and functions in a cross-platform compatible way.
#define lengthof(array)
Return the length of an fixed size array.
Definition stdafx.h:261
void GetStringWithArgs(StringBuilder &builder, StringID string, StringParameters &args, uint case_index, bool game_script)
Get a parsed string with most special stringcodes replaced by the string parameters.
Definition strings.cpp:335
EncodedString GetEncodedString(StringID str)
Encode a string with no parameters into an encoded string.
Definition strings.cpp:89
Functions related to OTTD's strings.
auto MakeParameters(Args &&... args)
Helper to create the StringParameters with its own buffer with the given parameter values.
StrongType::Typedef< uint32_t, struct StringIDTag, StrongType::Compare, StrongType::Integer > StringID
Numeric value that represents a string, independent of the selected language.
static constexpr StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames).
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
const T & GetOriginalValue() const
Returns the backupped value.
VehicleType type
Type of vehicle.
Class for storing amounts of cargo.
Definition cargo_type.h:120
static void InvalidateAllFrom(Source src)
Invalidates (sets source_id to INVALID_SOURCE) all cargo packets from given source.
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo type.
Definition cargotype.h:140
This structure is the same for both Industries and Houses.
Definition sprite.h:90
uint8_t draw_proc
This allows to specify a special drawing procedure.
Definition sprite.h:93
This is used to gather some data about animation drawing in the industry code Image_1-2-3 are in fact...
uint8_t image_1
image offset 1
uint8_t image_3
image offset 3
uint8_t image_2
image offset 2
int x
coordinate x of the first image offset
A special vehicle is one of the following:
uint8_t animation_substate
Sub state to time the change of the graphics/behaviour.
std::string GetName() const
Get the name of this grf.
GrfID grfid
grfid that introduced this entity.
const struct GRFFile * grffile
grf file that introduced this entity
bool HasGrfFile() const
Test if this entity was introduced by NewGRF.
uint8_t grf_version
GRF version (See https://newgrf-specs.tt-wiki.net/wiki/Version_numbers#GRF_version).
Definition newgrf.h:129
Data for managing the number and type of industries in the game.
Definition industry.h:309
void Reset()
Completely reset the industry build data.
void EconomyMonthlyLoop()
Monthly update of industry build data.
uint32_t wanted_inds
Number of wanted industries (bits 31-16), and a fraction (bits 15-0).
Definition industry.h:311
void SetupTargetCount()
Decide how many industries of each type are needed.
void TryBuildNewIndustry()
Try to create a random industry, during gameplay.
IndustryTypeBuildData builddata[NUM_INDUSTRYTYPES]
Industry build data for every industry type.
Definition industry.h:310
Defines the data structure for constructing industry.
IndustryCallbackMasks callback_mask
Bitmask of industry callbacks that have to be called.
bool IsProcessingIndustry() const
Is an industry with the spec a processing industry?
std::vector< uint8_t > random_sounds
Random sounds;.
Money GetRemovalCost() const
Get the cost for removing this industry Take note that the cost will always be zero for non-grf indus...
std::array< CargoType, INDUSTRY_NUM_INPUTS > accepts_cargo
16 accepted cargoes.
uint8_t appear_creation[NUM_LANDSCAPE]
Probability of appearance during map creation.
bool UsesOriginalEconomy() const
Determines whether this industrytype uses standard/newgrf production changes.
uint8_t minimal_cargo
minimum amount of cargo transported to the stations.
uint32_t removal_cost_multiplier
Base removal cost multiplier.
uint32_t prospecting_chance
Chance prospecting succeeds.
StringID production_up_text
Message appearing when the industry's production is increasing.
SubstituteGRFFileProps grf_prop
properties related to the grf file
StringID name
Displayed name of the industry.
bool IsRawIndustry() const
Is an industry with the spec a raw industry?
IndustryType conflicting[3]
Industries this industry cannot be close to.
uint8_t appear_ingame[NUM_LANDSCAPE]
Probability of appearance in game.
StringID production_down_text
Message appearing when the industry's production is decreasing.
IndustryBehaviours behaviour
How this industry will behave, and how others entities can use it.
StringID closure_text
Message appearing when the industry closes.
StringID new_industry_text
Message appearing when the industry is built.
std::vector< IndustryTileLayout > layouts
List of possible tile layouts for the industry.
bool enabled
entity still available (by default true).newgrf can disable it, though
Money GetConstructionCost() const
Get the cost for constructing this industry.
IndustryLifeTypes life_type
This is also known as Industry production flag, in newgrf specs.
IndustryCheck check_proc
Index to a procedure to check for conflicting circumstances.
Definition of one tile in an industry tile layout.
Defines the data structure of each individual tile of an industry.
IndustryTileSpecialFlags special_flags
Bitmask of extra flags used by the tile.
IndustryGfx anim_production
Animation frame to start when goods are produced.
Slope slopes_refused
slope pattern on which this tile cannot be built
AnimationInfo< IndustryAnimationTriggers > animation
Information about the animation (is it looping, how many loops etc).
std::array< int8_t, INDUSTRY_NUM_INPUTS > acceptance
Level of acceptance per cargo type (signed, may be negative!).
SubstituteGRFFileProps grf_prop
properties related to the grf file
bool anim_state
When true, the tile has to be drawn using the animation state instead of the construction stage.
IndustryTileCallbackMasks callback_mask
Bitmask of industry tile callbacks that have to be called.
IndustryGfx anim_next
Next frame in an animation.
std::array< CargoType, INDUSTRY_NUM_INPUTS > accepts_cargo
Cargo accepted by this tile.
Data for managing the number of industries of a single industry type.
Definition industry.h:294
uint32_t probability
Relative probability of building this industry.
Definition industry.h:295
uint16_t target_count
Desired number of industries of this type.
Definition industry.h:297
uint8_t min_number
Smallest number of industries that should exist (either 0 or 1).
Definition industry.h:296
void Reset()
Reset the entry.
bool GetIndustryTypeData(IndustryType it)
Set the probability and min_number fields for the industry type it for a running game.
uint16_t wait_count
Number of turns to wait before trying to build again.
Definition industry.h:299
uint16_t max_wait
Starting number of turns to wait (copied to wait_count).
Definition industry.h:298
CargoType cargo
Cargo type.
Definition industry.h:88
CargoType cargo
Cargo type.
Definition industry.h:76
HistoryData< ProducedHistory > history
History of cargo produced and transported for this month and 24 previous months.
Definition industry.h:79
uint8_t rate
Production rate.
Definition industry.h:78
Defines the internal data of a functional industry.
Definition industry.h:64
static Industry * GetRandom()
Return a random valid industry.
IndustryType type
type of industry.
Definition industry.h:117
Owner exclusive_supplier
Which company has exclusive rights to deliver cargo (INVALID_OWNER = anyone).
Definition industry.h:132
TimerGameCalendar::Date construction_date
Date of the construction of the industry.
Definition industry.h:129
IndustryControlFlags ctlflags
flags overriding standard behaviours
Definition industry.h:122
bool IsCargoAccepted() const
Test if this industry accepts any cargo.
Definition industry.h:225
PersistentStorage * psa
Persistent storage for NewGRF industries.
Definition industry.h:138
uint8_t prod_level
general production level
Definition industry.h:114
Colours random_colour
randomized colour of the industry, for display purpose
Definition industry.h:119
void RecomputeProductionMultipliers()
Recompute production_rate for current prod_level.
EncodedString text
General text with additional information.
Definition industry.h:134
std::string cached_name
NOSAVE: Cache of the resolved name of the industry.
Definition industry.h:126
const ProducedCargo & GetProduced(size_t slot) const
Safely get a produced cargo slot, or an empty data if the slot does not exist.
Definition industry.h:160
ValidHistoryMask valid_history
Mask of valid history records.
Definition industry.h:111
TimerGameEconomy::Year last_prod_year
last economy year of production
Definition industry.h:120
ProducedCargoes produced
produced cargo slots
Definition industry.h:112
uint16_t random
Random value used for randomisation of all kinds of things.
Definition industry.h:136
static void PostDestructor(size_t index)
Invalidating some stuff after removing item from the pool.
Town * town
Nearest town.
Definition industry.h:109
Owner founder
Founder of the industry.
Definition industry.h:128
uint8_t selected_layout
Which tile layout was used when creating the industry.
Definition industry.h:131
AcceptedCargoes accepted
accepted cargo slots
Definition industry.h:113
static uint16_t GetIndustryTypeCount(IndustryType type)
Get the count of industries for this type.
Definition industry.h:267
Owner owner
owner of the industry. Which SHOULD always be (imho) OWNER_NONE
Definition industry.h:118
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition industry.h:253
TileArea location
Location of the industry.
Definition industry.h:108
Station * neutral_station
Associated neutral station.
Definition industry.h:110
~Industry()
Remove any reference to this industry from the game.
IndustryConstructionType construction_type
Way the industry was constructed (.
Definition industry.h:130
StationList stations_near
NOSAVE: List of nearby stations.
Definition industry.h:125
bool IsCargoProduced() const
Test if this industry produces any cargo.
Definition industry.h:231
Owner exclusive_consumer
Which company has exclusive rights to take cargo (INVALID_OWNER = anyone).
Definition industry.h:133
uint16_t counter
used for animation and/or production (if available cargo)
Definition industry.h:115
uint8_t was_cargo_delivered
flag that indicate this has been the closest industry chosen for cargo delivery by a station....
Definition industry.h:121
bool TileBelongsToIndustry(TileIndex tile) const
Check if a given tile belongs to this industry.
Definition industry.h:150
static std::array< FlatSet< IndustryID >, NUM_INDUSTRYTYPES > industries
List of industries of each type.
Definition industry.h:279
static uint SizeX()
Get the size of the map along the X.
Definition map_func.h:262
static TileIndex WrapToMap(TileIndex tile)
'Wraps' the given "tile" so it is within the map.
Definition map_func.h:320
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:331
static uint SizeY()
Get the size of the map along the Y.
Definition map_func.h:271
static uint ScaleByLandProportion(uint n)
Scales the given value by the number of water tiles.
Definition map_func.h:308
static uint ScaleBySize1D(uint n)
Scales the given value by the maps circumference, where the given value is for a 256 by 256 map.
Definition map_func.h:344
static uint MaxY()
Gets the maximum Y coordinate within the map, including TileType::Void.
Definition map_func.h:298
static uint MaxX()
Gets the maximum X coordinate within the map, including TileType::Void.
Definition map_func.h:289
static uint Size()
Get the size of the map.
Definition map_func.h:280
If you change this, keep in mind that it is also saved in 2 other places:
Definition order_base.h:33
SpriteID sprite
The 'real' sprite.
Definition gfx_type.h:23
PaletteID pal
The palette (use PAL_NONE) if not needed).
Definition gfx_type.h:24
static Pool::IterateWrapper< Industry > Iterate(size_t from=0)
static T * Create(Targs &&... args)
static Industry * Get(auto index)
static Industry * GetIfValid(auto index)
static constexpr size_t MAX_SIZE
Structure to encapsulate the pseudo random number generators.
void SetSeed(uint32_t seed)
(Re)set the state of the random number generator.
uint32_t Next()
Generate the next pseudo random number.
A location from where cargo can come from (or go to).
Definition source_type.h:32
static Station * Get(auto index)
T * Next() const
Get next vehicle in the chain.
bool HasSpriteGroups() const
Check whether the entity has sprite groups.
Station data structure.
IndustryList industries_near
Cached list of industries near the station that can accept cargo,.
uint16_t subst_id
The id of the entity to replace.
Tile description for the 'land area information' tool.
Definition tile_cmd.h:40
std::optional< std::string > grf
newGRF used for the tile contents
Definition tile_cmd.h:51
StringID str
Description of the tile.
Definition tile_cmd.h:41
std::array< Owner, 4 > owner
Name of the owner(s).
Definition tile_cmd.h:43
uint64_t dparam
Parameter of the str string.
Definition tile_cmd.h:42
Tile information, used while rendering the tile.
Definition tile_cmd.h:34
Slope tileh
Slope of the tile.
Definition tile_cmd.h:35
TileIndex tile
Tile index.
Definition tile_cmd.h:36
Set of callback functions for performing tile operations of a given tile type.
Definition tile_cmd.h:214
uint32_t population
Current population of people.
Definition town.h:54
Town data structure.
Definition town.h:64
TileIndex xy
town center tile
Definition town.h:65
TownCache cache
Container for all cacheable data.
Definition town.h:67
Vehicle data structure.
CargoType cargo_type
type of cargo this vehicle is carrying
bool IsFrontEngine() const
Check if the vehicle is a front engine.
Owner owner
Which company owns the vehicle?
void DeleteSubsidyWith(Source source)
Delete the subsidies associated with a given cargo source type and id.
Definition subsidy.cpp:119
Functions related to subsidies.
Command definitions related to terraforming.
bool IsTileFlat(TileIndex tile, int *h)
Check if a given tile is flat.
Definition tile_map.cpp:94
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
Definition tile_map.cpp:135
int GetTileZ(TileIndex tile)
Get bottom height of the tile.
Definition tile_map.cpp:115
static bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
static uint TileHeight(Tile tile)
Returns the height of a tile.
Definition tile_map.h:29
int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
Definition tile_map.h:312
uint8_t GetAnimationFrame(Tile t)
Get the current animation frame.
Definition tile_map.h:250
bool IsValidTile(Tile tile)
Checks if a tile is valid.
Definition tile_map.h:161
TropicZone GetTropicZone(Tile tile)
Get the tropic zone.
Definition tile_map.h:238
void SetAnimationFrame(Tile t, uint8_t frame)
Set a new animation frame.
Definition tile_map.h:262
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
Definition tile_map.h:279
static TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition tile_map.h:96
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > > TileIndex
The index/ID of a Tile.
Definition tile_type.h:92
@ Desert
Tile is desert.
Definition tile_type.h:83
@ Rainforest
Rainforest tile.
Definition tile_type.h:84
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:100
static constexpr uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
@ Station
A tile of a station or airport.
Definition tile_type.h:54
@ Industry
Part of an industry.
Definition tile_type.h:57
@ Void
Invisible tiles at the SW and SE border.
Definition tile_type.h:56
@ Trees
Tile with one or more trees.
Definition tile_type.h:53
@ House
A house by a town.
Definition tile_type.h:52
@ Clear
A tile without any structures, i.e. grass, rocks, farm fields etc.
Definition tile_type.h:49
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
Type for iterating a sprial tile area.
Definition of Interval and OneShot timers.
Definition of the game-calendar-timer.
Definition of the game-economy-timer.
Definition of the tick-based game-timer.
Base of the town class.
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
bool IsTransparencySet(TransparencyOption to)
Check if the transparency option bit is set and if we aren't in the game menu (there's never transpar...
bool IsInvisibilitySet(TransparencyOption to)
Check if the invisibility option bit is set and if we aren't in the game menu (there's never transpar...
@ Industries
industries
Map accessors for tree tiles.
TreeGrowthStage GetTreeGrowth(Tile t)
Returns the tree growth stage.
Definition tree_map.h:196
TreeGround GetTreeGround(Tile t)
Returns the groundtype for tree tiles.
Definition tree_map.h:102
@ Shore
Shore.
Definition tree_map.h:56
@ Rough
Rough land.
Definition tree_map.h:54
@ Grown
Fully grown tree.
Definition tree_map.h:69
CommandCost EnsureNoVehicleOnGround(TileIndex tile)
Ensure there is no vehicle at the ground at the given position.
Definition vehicle.cpp:559
Functions related to vehicles.
@ Ship
Ship vehicle type.
@ Aircraft
Aircraft vehicle type.
@ Road
Road vehicle type.
@ Train
Train vehicle type.
void AddSortableSpriteToDraw(SpriteID image, PaletteID pal, int x, int y, int z, const SpriteBounds &bounds, bool transparent, const SubSprite *sub)
Draw a (transparent) sprite at given coordinates with a given bounding box.
Definition viewport.cpp:665
void AddChildSpriteScreen(SpriteID image, PaletteID pal, int x, int y, bool transparent, const SubSprite *sub, bool scale, bool relative)
Add a child sprite to a parent sprite.
Definition viewport.cpp:827
void DrawGroundSprite(SpriteID image, PaletteID pal, const SubSprite *sub, int extra_offs_x, int extra_offs_y)
Draws a ground sprite for the current tile.
Definition viewport.cpp:580
Functions related to (drawing on) viewports.
Functions related to water management.
void TileLoop_Water(TileIndex tile)
Tile callback function signature for running periodic tile updates.
bool IsTileOnWater(Tile t)
Tests if the tile was built on water.
Definition water_map.h:140
WaterClass
classes of water (for WaterTileType::Clear water tile type).
Definition water_map.h:41
@ Invalid
Used for industry tiles on land (also for oilrig if newgrf says so).
Definition water_map.h:45
bool HasTileWaterClass(Tile t)
Checks whether the tile has an waterclass associated.
Definition water_map.h:105
WaterClass GetWaterClass(Tile t)
Get the water class at a tile.
Definition water_map.h:116
bool IsWaterTile(Tile t)
Is it a water tile with plain water?
Definition water_map.h:194
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:1242
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:3377
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting).
Definition window.cpp:3255
Window functions not directly related to making/drawing windows.