OpenTTD Source 20250818-master-g1850ad1aa2
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 <http://www.gnu.org/licenses/>.
6 */
7
10#include "stdafx.h"
11#include "misc/history_type.hpp"
12#include "misc/history_func.hpp"
13#include "clear_map.h"
14#include "industry.h"
15#include "station_base.h"
16#include "landscape.h"
17#include "viewport_func.h"
18#include "command_func.h"
19#include "town.h"
20#include "news_func.h"
21#include "cheat_type.h"
22#include "company_base.h"
23#include "genworld.h"
24#include "tree_map.h"
25#include "newgrf_cargo.h"
26#include "newgrf_debug.h"
28#include "autoslope.h"
29#include "water.h"
30#include "strings_func.h"
31#include "window_func.h"
32#include "vehicle_func.h"
33#include "sound_func.h"
34#include "animated_tile_func.h"
35#include "effectvehicle_func.h"
36#include "effectvehicle_base.h"
37#include "ai/ai.hpp"
38#include "core/pool_func.hpp"
39#include "subsidy_func.h"
40#include "core/backup_type.hpp"
41#include "object_base.h"
42#include "game/game.hpp"
43#include "error.h"
44#include "string_func.h"
45#include "industry_cmd.h"
46#include "landscape_cmd.h"
47#include "terraform_cmd.h"
48#include "timer/timer.h"
52
53#include "table/strings.h"
54#include "table/industry_land.h"
56
57#include "safeguards.h"
58
59IndustryPool _industry_pool("Industry");
61
62void ShowIndustryViewWindow(IndustryID industry);
63void BuildOilRig(TileIndex tile);
64
65static uint8_t _industry_sound_ctr;
66static TileIndex _industry_sound_tile;
67
68std::array<FlatSet<IndustryID>, NUM_INDUSTRYTYPES> Industry::industries;
69
70IndustrySpec _industry_specs[NUM_INDUSTRYTYPES];
71IndustryTileSpec _industry_tile_specs[NUM_INDUSTRYTILES];
73
74static int WhoCanServiceIndustry(Industry *ind);
75
83{
84 auto industry_insert = std::copy(std::begin(_origin_industry_specs), std::end(_origin_industry_specs), std::begin(_industry_specs));
85 std::fill(industry_insert, std::end(_industry_specs), IndustrySpec{});
86
87 /* Enable only the current climate industries */
88 for (auto it = std::begin(_industry_specs); it != industry_insert; ++it) {
89 it->enabled = it->climate_availability.Test(_settings_game.game_creation.landscape);
90 }
91
92 auto industry_tile_insert = std::copy(std::begin(_origin_industry_tile_specs), std::end(_origin_industry_tile_specs), std::begin(_industry_tile_specs));
93 std::fill(industry_tile_insert, std::end(_industry_tile_specs), IndustryTileSpec{});
94
95 /* Reset any overrides that have been set. */
96 _industile_mngr.ResetOverride();
97 _industry_mngr.ResetOverride();
98}
99
108IndustryType GetIndustryType(Tile tile)
109{
110 assert(IsTileType(tile, MP_INDUSTRY));
111
112 const Industry *ind = Industry::GetByTile(tile);
113 assert(ind != nullptr);
114 return ind->type;
115}
116
125const IndustrySpec *GetIndustrySpec(IndustryType thistype)
126{
127 assert(thistype < NUM_INDUSTRYTYPES);
128 return &_industry_specs[thistype];
129}
130
140{
141 assert(gfx < NUM_INDUSTRYTILES);
142 return &_industry_tile_specs[gfx];
143}
144
145Industry::~Industry()
146{
147 if (CleaningPool()) return;
148
149 /* Industry can also be destroyed when not fully initialized.
150 * This means that we do not have to clear tiles either.
151 * Also we must not decrement industry counts in that case. */
152 if (this->location.w == 0) return;
153
154 const bool has_neutral_station = this->neutral_station != nullptr;
155
156 for (TileIndex tile_cur : this->location) {
157 if (IsTileType(tile_cur, MP_INDUSTRY)) {
158 if (GetIndustryIndex(tile_cur) == this->index) {
159 DeleteNewGRFInspectWindow(GSF_INDUSTRYTILES, tile_cur.base());
160
161 /* MakeWaterKeepingClass() can also handle 'land' */
162 MakeWaterKeepingClass(tile_cur, OWNER_NONE);
163 }
164 } else if (IsTileType(tile_cur, MP_STATION) && IsOilRig(tile_cur)) {
165 DeleteOilRig(tile_cur);
166 }
167 }
168
169 if (has_neutral_station) {
170 /* Remove possible docking tiles */
171 for (TileIndex tile_cur : this->location) {
173 }
174 }
175
176 if (GetIndustrySpec(this->type)->behaviour.Test(IndustryBehaviour::PlantFields)) {
177 TileArea ta = TileArea(this->location.tile, 0, 0).Expand(21);
178
179 /* Remove the farmland and convert it to regular tiles over time. */
180 for (TileIndex tile_cur : ta) {
181 if (IsTileType(tile_cur, MP_CLEAR) && IsClearGround(tile_cur, CLEAR_FIELDS) &&
182 GetIndustryIndexOfField(tile_cur) == this->index) {
183 SetIndustryIndexOfField(tile_cur, IndustryID::Invalid());
184 }
185 }
186 }
187
188 /* don't let any disaster vehicle target invalid industry */
190
191 /* Clear the persistent storage. */
192 delete this->psa;
193
195 industries.erase(this->index);
196
200 DeleteNewGRFInspectWindow(GSF_INDUSTRIES, this->index);
201
205
206 for (Station *st : this->stations_near) {
207 st->RemoveIndustryToDeliver(this);
208 }
209}
210
216{
217 InvalidateWindowData(WC_INDUSTRY_DIRECTORY, 0, IDIWD_FORCE_REBUILD);
219}
220
221
227{
228 if (Industry::GetNumItems() == 0) return nullptr;
229 int num = RandomRange((uint16_t)Industry::GetNumItems());
230 size_t index = std::numeric_limits<size_t>::max();
231
232 while (num >= 0) {
233 num--;
234 index++;
235
236 /* Make sure we have a valid industry */
237 while (!Industry::IsValidID(index)) {
238 index++;
239 assert(index < Industry::GetPoolSize());
240 }
241 }
242
243 return Industry::Get(index);
244}
245
246
247static void IndustryDrawSugarMine(const TileInfo *ti)
248{
249 if (!IsIndustryCompleted(ti->tile)) return;
250
251 const DrawIndustryAnimationStruct *d = &_draw_industry_spec1[GetAnimationFrame(ti->tile)];
252
253 AddChildSpriteScreen(SPR_IT_SUGAR_MINE_SIEVE + d->image_1, PAL_NONE, d->x, 0);
254
255 if (d->image_2 != 0) {
256 AddChildSpriteScreen(SPR_IT_SUGAR_MINE_CLOUDS + d->image_2 - 1, PAL_NONE, 8, 41);
257 }
258
259 if (d->image_3 != 0) {
260 AddChildSpriteScreen(SPR_IT_SUGAR_MINE_PILE + d->image_3 - 1, PAL_NONE,
261 _drawtile_proc1[d->image_3 - 1].x, _drawtile_proc1[d->image_3 - 1].y);
262 }
263}
264
265static void IndustryDrawToffeeQuarry(const TileInfo *ti)
266{
267 uint8_t x = 0;
268
269 if (IsIndustryCompleted(ti->tile)) {
270 x = _industry_anim_offs_toffee[GetAnimationFrame(ti->tile)];
271 if (x == 0xFF) {
272 x = 0;
273 }
274 }
275
276 AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_SHOVEL, PAL_NONE, 22 - x, 24 + x);
277 AddChildSpriteScreen(SPR_IT_TOFFEE_QUARRY_TOFFEE, PAL_NONE, 6, 14);
278}
279
280static void IndustryDrawBubbleGenerator( const TileInfo *ti)
281{
282 if (IsIndustryCompleted(ti->tile)) {
283 AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_BUBBLE, PAL_NONE, 5, _industry_anim_offs_bubbles[GetAnimationFrame(ti->tile)]);
284 }
285 AddChildSpriteScreen(SPR_IT_BUBBLE_GENERATOR_SPRING, PAL_NONE, 3, 67);
286}
287
288static void IndustryDrawToyFactory(const TileInfo *ti)
289{
290 const DrawIndustryAnimationStruct *d = &_industry_anim_offs_toys[GetAnimationFrame(ti->tile)];
291
292 if (d->image_1 != 0xFF) {
293 AddChildSpriteScreen(SPR_IT_TOY_FACTORY_CLAY, PAL_NONE, d->x, 96 + d->image_1);
294 }
295
296 if (d->image_2 != 0xFF) {
297 AddChildSpriteScreen(SPR_IT_TOY_FACTORY_ROBOT, PAL_NONE, 16 - d->image_2 * 2, 100 + d->image_2);
298 }
299
300 AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP, PAL_NONE, 7, d->image_3);
301 AddChildSpriteScreen(SPR_IT_TOY_FACTORY_STAMP_HOLDER, PAL_NONE, 0, 42);
302}
303
304static void IndustryDrawCoalPlantSparks(const TileInfo *ti)
305{
306 if (IsIndustryCompleted(ti->tile)) {
307 uint8_t image = GetAnimationFrame(ti->tile);
308
309 if (image != 0 && image < 7) {
310 AddChildSpriteScreen(image + SPR_IT_POWER_PLANT_TRANSFORMERS,
311 PAL_NONE,
312 _coal_plant_sparks[image - 1].x,
313 _coal_plant_sparks[image - 1].y
314 );
315 }
316 }
317}
318
319typedef void IndustryDrawTileProc(const TileInfo *ti);
320static IndustryDrawTileProc * const _industry_draw_tile_procs[5] = {
321 IndustryDrawSugarMine,
322 IndustryDrawToffeeQuarry,
323 IndustryDrawBubbleGenerator,
324 IndustryDrawToyFactory,
325 IndustryDrawCoalPlantSparks,
326};
327
328static void DrawTile_Industry(TileInfo *ti)
329{
330 IndustryGfx gfx = GetIndustryGfx(ti->tile);
332 const IndustryTileSpec *indts = GetIndustryTileSpec(gfx);
333
334 /* Retrieve pointer to the draw industry tile struct */
335 if (gfx >= NEW_INDUSTRYTILEOFFSET) {
336 /* Draw the tile using the specialized method of newgrf industrytile.
337 * DrawNewIndustry will return false if ever the resolver could not
338 * find any sprite to display. So in this case, we will jump on the
339 * substitute gfx instead. */
340 if (indts->grf_prop.HasSpriteGroups() && DrawNewIndustryTile(ti, ind, gfx, indts)) {
341 return;
342 } else {
343 /* No sprite group (or no valid one) found, meaning no graphics associated.
344 * Use the substitute one instead */
345 if (indts->grf_prop.subst_id != INVALID_INDUSTRYTILE) {
346 gfx = indts->grf_prop.subst_id;
347 /* And point the industrytile spec accordingly */
348 indts = GetIndustryTileSpec(gfx);
349 }
350 }
351 }
352
353 const DrawBuildingsTileStruct *dits = &_industry_draw_tile_data[gfx << 2 | (indts->anim_state ?
356
357 SpriteID image = dits->ground.sprite;
358
359 /* DrawFoundation() modifies ti->z and ti->tileh */
361
362 /* If the ground sprite is the default flat water sprite, draw also canal/river borders.
363 * Do not do this if the tile's WaterClass is 'land'. */
364 if (image == SPR_FLAT_WATER_TILE && IsTileOnWater(ti->tile)) {
365 DrawWaterClassGround(ti);
366 } else {
368 }
369
370 /* If industries are transparent and invisible, do not draw the upper part */
371 if (IsInvisibilitySet(TO_INDUSTRIES)) return;
372
373 /* Add industry on top of the ground? */
374 image = dits->building.sprite;
375 if (image != 0) {
377 *ti, *dits, IsTransparencySet(TO_INDUSTRIES));
378
379 if (IsTransparencySet(TO_INDUSTRIES)) return;
380 }
381
382 {
383 int proc = dits->draw_proc - 1;
384 if (proc >= 0) _industry_draw_tile_procs[proc](ti);
385 }
386}
387
388static int GetSlopePixelZ_Industry(TileIndex tile, uint, uint, bool)
389{
390 return GetTileMaxPixelZ(tile);
391}
392
393static Foundation GetFoundation_Industry(TileIndex tile, Slope tileh)
394{
395 IndustryGfx gfx = GetIndustryGfx(tile);
396
397 /* For NewGRF industry tiles we might not be drawing a foundation. We need to
398 * account for this, as other structures should
399 * draw the wall of the foundation in this case.
400 */
401 if (gfx >= NEW_INDUSTRYTILEOFFSET) {
402 const IndustryTileSpec *indts = GetIndustryTileSpec(gfx);
404 uint32_t callback_res = GetIndustryTileCallback(CBID_INDTILE_DRAW_FOUNDATIONS, 0, 0, gfx, Industry::GetByTile(tile), tile);
405 if (callback_res != CALLBACK_FAILED && !ConvertBooleanCallback(indts->grf_prop.grffile, CBID_INDTILE_DRAW_FOUNDATIONS, callback_res)) return FOUNDATION_NONE;
406 }
407 }
408 return FlatteningFoundation(tileh);
409}
410
411static void AddAcceptedCargo_Industry(TileIndex tile, CargoArray &acceptance, CargoTypes &always_accepted)
412{
413 IndustryGfx gfx = GetIndustryGfx(tile);
414 const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);
415 const Industry *ind = Industry::GetByTile(tile);
416
417 /* Starting point for acceptance */
418 auto accepts_cargo = itspec->accepts_cargo;
419 auto cargo_acceptance = itspec->acceptance;
420
422 /* Copy all accepted cargoes from industry itself */
423 for (const auto &a : ind->accepted) {
424 auto pos = std::ranges::find(accepts_cargo, a.cargo);
425 if (pos == std::end(accepts_cargo)) {
426 /* Not found, insert */
427 pos = std::ranges::find(accepts_cargo, INVALID_CARGO);
428 if (pos == std::end(accepts_cargo)) continue; // nowhere to place, give up on this one
429 *pos = a.cargo;
430 }
431 cargo_acceptance[std::distance(std::begin(accepts_cargo), pos)] += 8;
432 }
433 }
434
436 /* Try callback for accepts list, if success override all existing accepts */
437 uint16_t res = GetIndustryTileCallback(CBID_INDTILE_ACCEPT_CARGO, 0, 0, gfx, Industry::GetByTile(tile), tile);
438 if (res != CALLBACK_FAILED) {
439 accepts_cargo.fill(INVALID_CARGO);
440 for (uint i = 0; i < INDUSTRY_ORIGINAL_NUM_INPUTS; i++) accepts_cargo[i] = GetCargoTranslation(GB(res, i * 5, 5), itspec->grf_prop.grffile);
441 }
442 }
443
445 /* Try callback for acceptance list, if success override all existing acceptance */
446 uint16_t res = GetIndustryTileCallback(CBID_INDTILE_CARGO_ACCEPTANCE, 0, 0, gfx, Industry::GetByTile(tile), tile);
447 if (res != CALLBACK_FAILED) {
448 cargo_acceptance.fill(0);
449 for (uint i = 0; i < INDUSTRY_ORIGINAL_NUM_INPUTS; i++) cargo_acceptance[i] = GB(res, i * 4, 4);
450 }
451 }
452
453 for (uint8_t i = 0; i < std::size(itspec->accepts_cargo); i++) {
454 CargoType cargo = accepts_cargo[i];
455 if (!IsValidCargoType(cargo) || cargo_acceptance[i] <= 0) continue; // work only with valid cargoes
456
457 /* Add accepted cargo */
458 acceptance[cargo] += cargo_acceptance[i];
459
460 /* Maybe set 'always accepted' bit (if it's not set already) */
461 if (HasBit(always_accepted, cargo)) continue;
462
463 /* Test whether the industry itself accepts the cargo type */
464 if (ind->IsCargoAccepted(cargo)) continue;
465
466 /* If the industry itself doesn't accept this cargo, set 'always accepted' bit */
467 SetBit(always_accepted, cargo);
468 }
469}
470
471static void GetTileDesc_Industry(TileIndex tile, TileDesc &td)
472{
473 const Industry *i = Industry::GetByTile(tile);
474 const IndustrySpec *is = GetIndustrySpec(i->type);
475
476 td.owner[0] = i->owner;
477 td.str = is->name;
478 if (!IsIndustryCompleted(tile)) {
479 td.dparam = td.str;
480 td.str = STR_LAI_TOWN_INDUSTRY_DESCRIPTION_UNDER_CONSTRUCTION;
481 }
482
483 if (is->grf_prop.HasGrfFile()) {
485 }
486}
487
488static CommandCost ClearTile_Industry(TileIndex tile, DoCommandFlags flags)
489{
490 Industry *i = Industry::GetByTile(tile);
491 const IndustrySpec *indspec = GetIndustrySpec(i->type);
492
493 /* water can destroy industries
494 * in editor you can bulldoze industries
495 * with magic_bulldozer cheat you can destroy industries
496 * (area around OILRIG is water, so water shouldn't flood it
497 */
498 if ((_current_company != OWNER_WATER && _game_mode != GM_EDITOR &&
500 flags.Test(DoCommandFlag::Auto) ||
503 HasBit(GetIndustryTileSpec(GetIndustryGfx(tile))->slopes_refused, 5)))) {
504
505 if (flags.Test(DoCommandFlag::Auto)) {
506 return CommandCostWithParam(STR_ERROR_GENERIC_OBJECT_IN_THE_WAY, indspec->name);
507 }
509 }
510
511 if (flags.Test(DoCommandFlag::Execute)) {
512 AI::BroadcastNewEvent(new ScriptEventIndustryClose(i->index));
513 Game::NewEvent(new ScriptEventIndustryClose(i->index));
514 delete i;
515 }
517}
518
525{
526 Industry *i = Industry::GetByTile(tile);
527 const IndustrySpec *indspec = GetIndustrySpec(i->type);
528 bool moved_cargo = false;
529
530 for (auto &p : i->produced) {
531 uint cw = ClampTo<uint8_t>(p.waiting);
532 if (cw > indspec->minimal_cargo && IsValidCargoType(p.cargo)) {
533 p.waiting -= cw;
534
535 /* fluctuating economy? */
536 if (EconomyIsInRecession()) cw = (cw + 1) / 2;
537
538 p.history[THIS_MONTH].production += cw;
539
540 uint am = MoveGoodsToStation(p.cargo, cw, {i->index, SourceType::Industry}, i->stations_near, i->exclusive_consumer);
541 p.history[THIS_MONTH].transported += am;
542
543 moved_cargo |= (am != 0);
544 }
545 }
546
547 return moved_cargo;
548}
549
550static void AnimateSugarSieve(TileIndex tile)
551{
552 uint8_t m = GetAnimationFrame(tile) + 1;
553
555 switch (m & 7) {
556 case 2: SndPlayTileFx(SND_2D_SUGAR_MINE_1, tile); break;
557 case 6: SndPlayTileFx(SND_29_SUGAR_MINE_2, tile); break;
558 }
559 }
560
561 if (m >= 96) {
562 m = 0;
563 DeleteAnimatedTile(tile);
564 }
565 SetAnimationFrame(tile, m);
566
568}
569
570static void AnimateToffeeQuarry(TileIndex tile)
571{
572 uint8_t m = GetAnimationFrame(tile);
573
574 if (_industry_anim_offs_toffee[m] == 0xFF && _settings_client.sound.ambient) {
575 SndPlayTileFx(SND_30_TOFFEE_QUARRY, tile);
576 }
577
578 if (++m >= 70) {
579 m = 0;
580 DeleteAnimatedTile(tile);
581 }
582 SetAnimationFrame(tile, m);
583
585}
586
587static void AnimateBubbleCatcher(TileIndex tile)
588{
589 uint8_t m = GetAnimationFrame(tile);
590
591 if (++m >= 40) {
592 m = 0;
593 DeleteAnimatedTile(tile);
594 }
595 SetAnimationFrame(tile, m);
596
598}
599
600static void AnimatePowerPlantSparks(TileIndex tile)
601{
602 uint8_t m = GetAnimationFrame(tile);
603 if (m == 6) {
604 SetAnimationFrame(tile, 0);
605 DeleteAnimatedTile(tile);
606 } else {
607 SetAnimationFrame(tile, m + 1);
608 }
610}
611
612static void AnimateToyFactory(TileIndex tile)
613{
614 uint8_t m = GetAnimationFrame(tile) + 1;
615
616 switch (m) {
617 case 1: if (_settings_client.sound.ambient) SndPlayTileFx(SND_2C_TOY_FACTORY_1, tile); break;
618 case 23: if (_settings_client.sound.ambient) SndPlayTileFx(SND_2B_TOY_FACTORY_2, tile); break;
619 case 28: if (_settings_client.sound.ambient) SndPlayTileFx(SND_2A_TOY_FACTORY_3, tile); break;
620 default:
621 if (m >= 50) {
622 int n = GetIndustryAnimationLoop(tile) + 1;
623 m = 0;
624 if (n >= 8) {
625 n = 0;
626 DeleteAnimatedTile(tile);
627 }
629 }
630 }
631
632 SetAnimationFrame(tile, m);
634}
635
636static void AnimatePlasticFountain(TileIndex tile, IndustryGfx gfx)
637{
638 gfx = (gfx < GFX_PLASTIC_FOUNTAIN_ANIMATED_8) ? gfx + 1 : GFX_PLASTIC_FOUNTAIN_ANIMATED_1;
639 SetIndustryGfx(tile, gfx);
641}
642
643static void AnimateOilWell(TileIndex tile, IndustryGfx gfx)
644{
645 bool b = Chance16(1, 7);
646 uint8_t m = GetAnimationFrame(tile) + 1;
647 if (m == 4 && (m = 0, ++gfx) == GFX_OILWELL_ANIMATED_3 + 1 && (gfx = GFX_OILWELL_ANIMATED_1, b)) {
648 SetIndustryGfx(tile, GFX_OILWELL_NOT_ANIMATED);
650 DeleteAnimatedTile(tile);
651 } else {
652 SetAnimationFrame(tile, m);
653 SetIndustryGfx(tile, gfx);
654 }
656}
657
658static void AnimateMineTower(TileIndex tile)
659{
660 int state = TimerGameTick::counter & 0x7FF;
661
662 if ((state -= 0x400) < 0) return;
663
664 if (state < 0x1A0) {
665 if (state < 0x20 || state >= 0x180) {
666 uint8_t m = GetAnimationFrame(tile);
667 if (!(m & 0x40)) {
668 SetAnimationFrame(tile, m | 0x40);
669 if (_settings_client.sound.ambient) SndPlayTileFx(SND_0B_MINE, tile);
670 }
671 if (state & 7) return;
672 } else {
673 if (state & 3) return;
674 }
675 uint8_t m = (GetAnimationFrame(tile) + 1) | 0x40;
676 if (m > 0xC2) m = 0xC0;
677 SetAnimationFrame(tile, m);
679 } else if (state >= 0x200 && state < 0x3A0) {
680 int i = (state < 0x220 || state >= 0x380) ? 7 : 3;
681 if (state & i) return;
682
683 uint8_t m = (GetAnimationFrame(tile) & 0xBF) - 1;
684 if (m < 0x80) m = 0x82;
685 SetAnimationFrame(tile, m);
687 }
688}
689
690static void AnimateTile_Industry(TileIndex tile)
691{
692 IndustryGfx gfx = GetIndustryGfx(tile);
693
694 if (GetIndustryTileSpec(gfx)->animation.status != AnimationStatus::NoAnimation) {
695 AnimateNewIndustryTile(tile);
696 return;
697 }
698
699 switch (gfx) {
700 case GFX_SUGAR_MINE_SIEVE:
701 if ((TimerGameTick::counter & 1) == 0) AnimateSugarSieve(tile);
702 break;
703
704 case GFX_TOFFEE_QUARY:
705 if ((TimerGameTick::counter & 3) == 0) AnimateToffeeQuarry(tile);
706 break;
707
708 case GFX_BUBBLE_CATCHER:
709 if ((TimerGameTick::counter & 1) == 0) AnimateBubbleCatcher(tile);
710 break;
711
712 case GFX_POWERPLANT_SPARKS:
713 if ((TimerGameTick::counter & 3) == 0) AnimatePowerPlantSparks(tile);
714 break;
715
716 case GFX_TOY_FACTORY:
717 if ((TimerGameTick::counter & 1) == 0) AnimateToyFactory(tile);
718 break;
719
720 case GFX_PLASTIC_FOUNTAIN_ANIMATED_1: case GFX_PLASTIC_FOUNTAIN_ANIMATED_2:
721 case GFX_PLASTIC_FOUNTAIN_ANIMATED_3: case GFX_PLASTIC_FOUNTAIN_ANIMATED_4:
722 case GFX_PLASTIC_FOUNTAIN_ANIMATED_5: case GFX_PLASTIC_FOUNTAIN_ANIMATED_6:
723 case GFX_PLASTIC_FOUNTAIN_ANIMATED_7: case GFX_PLASTIC_FOUNTAIN_ANIMATED_8:
724 if ((TimerGameTick::counter & 3) == 0) AnimatePlasticFountain(tile, gfx);
725 break;
726
727 case GFX_OILWELL_ANIMATED_1:
728 case GFX_OILWELL_ANIMATED_2:
729 case GFX_OILWELL_ANIMATED_3:
730 if ((TimerGameTick::counter & 7) == 0) AnimateOilWell(tile, gfx);
731 break;
732
733 case GFX_COAL_MINE_TOWER_ANIMATED:
734 case GFX_COPPER_MINE_TOWER_ANIMATED:
735 case GFX_GOLD_MINE_TOWER_ANIMATED:
736 AnimateMineTower(tile);
737 break;
738 }
739}
740
741static void CreateChimneySmoke(TileIndex tile)
742{
743 uint x = TileX(tile) * TILE_SIZE;
744 uint y = TileY(tile) * TILE_SIZE;
745 int z = GetTileMaxPixelZ(tile);
746
747 CreateEffectVehicle(x + 15, y + 14, z + 59, EV_CHIMNEY_SMOKE);
748}
749
750static void MakeIndustryTileBigger(TileIndex tile)
751{
752 uint8_t cnt = GetIndustryConstructionCounter(tile) + 1;
753 if (cnt != 4) {
755 return;
756 }
757
758 uint8_t stage = GetIndustryConstructionStage(tile) + 1;
760 SetIndustryConstructionStage(tile, stage);
761 TriggerIndustryTileAnimation_ConstructionStageChanged(tile, false);
762 if (stage == INDUSTRY_COMPLETED) SetIndustryCompleted(tile);
763
765
766 if (!IsIndustryCompleted(tile)) return;
767
768 IndustryGfx gfx = GetIndustryGfx(tile);
769 if (gfx >= NEW_INDUSTRYTILEOFFSET) {
770 /* New industries are already animated on construction. */
771 return;
772 }
773
774 switch (gfx) {
775 case GFX_POWERPLANT_CHIMNEY:
776 CreateChimneySmoke(tile);
777 break;
778
779 case GFX_OILRIG_1: {
780 /* Do not require an industry tile to be after the first two GFX_OILRIG_1
781 * tiles (like the default oil rig). Do a proper check to ensure the
782 * tiles belong to the same industry and based on that build the oil rig's
783 * station. */
784 TileIndex other = tile + TileDiffXY(0, 1);
785
786 if (IsTileType(other, MP_INDUSTRY) &&
787 GetIndustryGfx(other) == GFX_OILRIG_1 &&
788 GetIndustryIndex(tile) == GetIndustryIndex(other)) {
789 BuildOilRig(tile);
790 }
791 break;
792 }
793
794 case GFX_TOY_FACTORY:
795 case GFX_BUBBLE_CATCHER:
796 case GFX_TOFFEE_QUARY:
797 SetAnimationFrame(tile, 0);
799 break;
800
801 case GFX_PLASTIC_FOUNTAIN_ANIMATED_1: case GFX_PLASTIC_FOUNTAIN_ANIMATED_2:
802 case GFX_PLASTIC_FOUNTAIN_ANIMATED_3: case GFX_PLASTIC_FOUNTAIN_ANIMATED_4:
803 case GFX_PLASTIC_FOUNTAIN_ANIMATED_5: case GFX_PLASTIC_FOUNTAIN_ANIMATED_6:
804 case GFX_PLASTIC_FOUNTAIN_ANIMATED_7: case GFX_PLASTIC_FOUNTAIN_ANIMATED_8:
805 AddAnimatedTile(tile, false);
806 break;
807 }
808}
809
810static void TileLoopIndustry_BubbleGenerator(TileIndex tile)
811{
812 static const int8_t _bubble_spawn_location[3][4] = {
813 { 11, 0, -4, -14 },
814 { -4, -10, -4, 1 },
815 { 49, 59, 60, 65 },
816 };
817
818 if (_settings_client.sound.ambient) SndPlayTileFx(SND_2E_BUBBLE_GENERATOR, tile);
819
820 int dir = Random() & 3;
821
823 TileX(tile) * TILE_SIZE + _bubble_spawn_location[0][dir],
824 TileY(tile) * TILE_SIZE + _bubble_spawn_location[1][dir],
825 _bubble_spawn_location[2][dir],
827 );
828
829 if (v != nullptr) v->animation_substate = dir;
830}
831
832static void TileLoop_Industry(TileIndex tile)
833{
834 if (IsTileOnWater(tile)) TileLoop_Water(tile);
835
836 /* Normally this doesn't happen, but if an industry NewGRF is removed
837 * an industry that was previously build on water can now be flooded.
838 * If this happens the tile is no longer an industry tile after
839 * returning from TileLoop_Water. */
840 if (!IsTileType(tile, MP_INDUSTRY)) return;
841
843
844 if (!IsIndustryCompleted(tile)) {
845 MakeIndustryTileBigger(tile);
846 return;
847 }
848
849 if (_game_mode == GM_EDITOR) return;
850
851 if (TransportIndustryGoods(tile) && !TriggerIndustryAnimation(Industry::GetByTile(tile), IndustryAnimationTrigger::CargoDistributed)) {
853
854 if (newgfx != INDUSTRYTILE_NOANIM) {
857 SetIndustryGfx(tile, newgfx);
859 return;
860 }
861 }
862
863 if (TriggerIndustryTileAnimation(tile, IndustryAnimationTrigger::TileLoop)) return;
864
865 IndustryGfx newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_next;
866 if (newgfx != INDUSTRYTILE_NOANIM) {
868 SetIndustryGfx(tile, newgfx);
870 return;
871 }
872
873 IndustryGfx gfx = GetIndustryGfx(tile);
874 switch (gfx) {
875 case GFX_COAL_MINE_TOWER_NOT_ANIMATED:
876 case GFX_COPPER_MINE_TOWER_NOT_ANIMATED:
877 case GFX_GOLD_MINE_TOWER_NOT_ANIMATED:
878 if (!(TimerGameTick::counter & 0x400) && Chance16(1, 2)) {
879 switch (gfx) {
880 case GFX_COAL_MINE_TOWER_NOT_ANIMATED: gfx = GFX_COAL_MINE_TOWER_ANIMATED; break;
881 case GFX_COPPER_MINE_TOWER_NOT_ANIMATED: gfx = GFX_COPPER_MINE_TOWER_ANIMATED; break;
882 case GFX_GOLD_MINE_TOWER_NOT_ANIMATED: gfx = GFX_GOLD_MINE_TOWER_ANIMATED; break;
883 }
884 SetIndustryGfx(tile, gfx);
885 SetAnimationFrame(tile, 0x80);
886 AddAnimatedTile(tile);
887 }
888 break;
889
890 case GFX_OILWELL_NOT_ANIMATED:
891 if (Chance16(1, 6)) {
892 SetIndustryGfx(tile, GFX_OILWELL_ANIMATED_1);
893 SetAnimationFrame(tile, 0);
894 AddAnimatedTile(tile);
895 }
896 break;
897
898 case GFX_COAL_MINE_TOWER_ANIMATED:
899 case GFX_COPPER_MINE_TOWER_ANIMATED:
900 case GFX_GOLD_MINE_TOWER_ANIMATED:
901 if (!(TimerGameTick::counter & 0x400)) {
902 switch (gfx) {
903 case GFX_COAL_MINE_TOWER_ANIMATED: gfx = GFX_COAL_MINE_TOWER_NOT_ANIMATED; break;
904 case GFX_COPPER_MINE_TOWER_ANIMATED: gfx = GFX_COPPER_MINE_TOWER_NOT_ANIMATED; break;
905 case GFX_GOLD_MINE_TOWER_ANIMATED: gfx = GFX_GOLD_MINE_TOWER_NOT_ANIMATED; break;
906 }
907 SetIndustryGfx(tile, gfx);
910 DeleteAnimatedTile(tile);
912 }
913 break;
914
915 case GFX_POWERPLANT_SPARKS:
916 if (Chance16(1, 3)) {
917 if (_settings_client.sound.ambient) SndPlayTileFx(SND_0C_POWER_STATION, tile);
918 AddAnimatedTile(tile);
919 }
920 break;
921
922 case GFX_COPPER_MINE_CHIMNEY:
924 break;
925
926
927 case GFX_TOY_FACTORY: {
928 Industry *i = Industry::GetByTile(tile);
929 if (i->was_cargo_delivered) {
930 i->was_cargo_delivered = false;
932 AddAnimatedTile(tile);
933 }
934 }
935 break;
936
937 case GFX_BUBBLE_GENERATOR:
938 TileLoopIndustry_BubbleGenerator(tile);
939 break;
940
941 case GFX_TOFFEE_QUARY:
942 AddAnimatedTile(tile);
943 break;
944
945 case GFX_SUGAR_MINE_SIEVE:
946 if (Chance16(1, 3)) AddAnimatedTile(tile);
947 break;
948 }
949}
950
951static bool ClickTile_Industry(TileIndex tile)
952{
953 ShowIndustryViewWindow(GetIndustryIndex(tile));
954 return true;
955}
956
957static TrackStatus GetTileTrackStatus_Industry(TileIndex, TransportType, uint, DiagDirection)
958{
959 return 0;
960}
961
962static void ChangeTileOwner_Industry(TileIndex tile, Owner old_owner, Owner new_owner)
963{
964 /* If the founder merges, the industry was created by the merged company */
965 Industry *i = Industry::GetByTile(tile);
966 if (i->founder == old_owner) i->founder = (new_owner == INVALID_OWNER) ? OWNER_NONE : new_owner;
967
968 if (i->exclusive_supplier == old_owner) i->exclusive_supplier = new_owner;
969 if (i->exclusive_consumer == old_owner) i->exclusive_consumer = new_owner;
970}
971
978{
979 /* Check for industry tile */
980 if (!IsTileType(tile, MP_INDUSTRY)) return false;
981
982 const Industry *ind = Industry::GetByTile(tile);
983
984 /* Check for organic industry (i.e. not processing or extractive) */
986
987 /* Check for wood production */
988 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; });
989}
990
991static const uint8_t _plantfarmfield_type[] = {1, 1, 1, 1, 1, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6};
992
1000static bool IsSuitableForFarmField(TileIndex tile, bool allow_fields)
1001{
1002 switch (GetTileType(tile)) {
1003 case MP_CLEAR: return !IsSnowTile(tile) && !IsClearGround(tile, CLEAR_DESERT) && (allow_fields || !IsClearGround(tile, CLEAR_FIELDS));
1004 case MP_TREES: return GetTreeGround(tile) != TREE_GROUND_SHORE;
1005 default: return false;
1006 }
1007}
1008
1016static void SetupFarmFieldFence(TileIndex tile, int size, uint8_t type, DiagDirection side)
1017{
1019 TileIndexDiff neighbour_diff = TileOffsByDiagDir(side);
1020
1021 do {
1022 tile = Map::WrapToMap(tile);
1023
1024 if (IsTileType(tile, MP_CLEAR) && IsClearGround(tile, CLEAR_FIELDS)) {
1025 TileIndex neighbour = tile + neighbour_diff;
1026 if (!IsTileType(neighbour, MP_CLEAR) || !IsClearGround(neighbour, CLEAR_FIELDS) || GetFence(neighbour, ReverseDiagDir(side)) == 0) {
1027 /* Add fence as long as neighbouring tile does not already have a fence in the same position. */
1028 uint8_t or_ = type;
1029
1030 if (or_ == 1 && Chance16(1, 7)) or_ = 2;
1031
1032 SetFence(tile, side, or_);
1033 }
1034 }
1035
1036 tile += diff;
1037 } while (--size);
1038}
1039
1040static void PlantFarmField(TileIndex tile, IndustryID industry)
1041{
1042 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) {
1043 if (GetTileZ(tile) + 2 >= GetSnowLine()) return;
1044 }
1045
1046 /* determine field size */
1047 uint32_t r = (Random() & 0x303) + 0x404;
1048 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) r += 0x404;
1049 uint size_x = GB(r, 0, 8);
1050 uint size_y = GB(r, 8, 8);
1051
1052 TileArea ta(tile - TileDiffXY(std::min(TileX(tile), size_x / 2), std::min(TileY(tile), size_y / 2)), size_x, size_y);
1053 ta.ClampToMap();
1054
1055 if (ta.w == 0 || ta.h == 0) return;
1056
1057 /* check the amount of bad tiles */
1058 int count = 0;
1059 for (TileIndex cur_tile : ta) {
1060 assert(cur_tile < Map::Size());
1061 count += IsSuitableForFarmField(cur_tile, false);
1062 }
1063 if (count * 2 < ta.w * ta.h) return;
1064
1065 /* determine type of field */
1066 r = Random();
1067 uint counter = GB(r, 5, 3);
1068 uint field_type = GB(r, 8, 8) * 9 >> 8;
1069
1070 /* make field */
1071 for (TileIndex cur_tile : ta) {
1072 assert(cur_tile < Map::Size());
1073 if (IsSuitableForFarmField(cur_tile, true)) {
1074 MakeField(cur_tile, field_type, industry);
1075 SetClearCounter(cur_tile, counter);
1076 MarkTileDirtyByTile(cur_tile);
1077 }
1078 }
1079
1080 int type = 3;
1081 if (_settings_game.game_creation.landscape != LandscapeType::Arctic && _settings_game.game_creation.landscape != LandscapeType::Tropic) {
1082 type = _plantfarmfield_type[Random() & 0xF];
1083 }
1084
1085 SetupFarmFieldFence(ta.tile, ta.h, type, DIAGDIR_NE);
1086 SetupFarmFieldFence(ta.tile, ta.w, type, DIAGDIR_NW);
1087 SetupFarmFieldFence(ta.tile + TileDiffXY(ta.w - 1, 0), ta.h, type, DIAGDIR_SW);
1088 SetupFarmFieldFence(ta.tile + TileDiffXY(0, ta.h - 1), ta.w, type, DIAGDIR_SE);
1089}
1090
1091void PlantRandomFarmField(const Industry *i)
1092{
1093 int x = i->location.w / 2 + Random() % 31 - 16;
1094 int y = i->location.h / 2 + Random() % 31 - 16;
1095
1096 TileIndex tile = TileAddWrap(i->location.tile, x, y);
1097
1098 if (tile != INVALID_TILE) PlantFarmField(tile, i->index);
1099}
1100
1106{
1107 /* Don't process lumber mill if cargo is not set up correctly. */
1108 auto itp = std::begin(i->produced);
1109 if (itp == std::end(i->produced) || !IsValidCargoType(itp->cargo)) return;
1110
1111 /* We only want to cut trees if all tiles are completed. */
1112 for (TileIndex tile_cur : i->location) {
1113 if (i->TileBelongsToIndustry(tile_cur)) {
1114 if (!IsIndustryCompleted(tile_cur)) return;
1115 }
1116 }
1117
1118 for (auto tile : SpiralTileSequence(i->location.tile, 40)) { // 40x40 tiles to search.
1119 if (!IsTileType(tile, MP_TREES) || GetTreeGrowth(tile) < TreeGrowthStage::Grown) continue;
1120
1121 /* found a tree */
1122 _industry_sound_ctr = 1;
1123 _industry_sound_tile = tile;
1124 if (_settings_client.sound.ambient) SndPlayTileFx(SND_38_LUMBER_MILL_1, tile);
1125
1128
1129 /* Add according value to waiting cargo. */
1130 itp->waiting = ClampTo<uint16_t>(itp->waiting + ScaleByCargoScale(45, false));
1131 break;
1132 }
1133}
1134
1140static void ProduceIndustryGoodsHelper(Industry *i, bool scale)
1141{
1142 for (auto &p : i->produced) {
1143 if (!IsValidCargoType(p.cargo)) continue;
1144
1145 uint16_t amount = p.rate;
1146 if (scale) amount = ScaleByCargoScale(amount, false);
1147
1148 p.waiting = ClampTo<uint16_t>(p.waiting + amount);
1149 }
1150}
1151
1152static void ProduceIndustryGoods(Industry *i)
1153{
1154 const IndustrySpec *indsp = GetIndustrySpec(i->type);
1155
1156 /* play a sound? */
1157 if ((i->counter & 0x3F) == 0) {
1158 uint32_t r;
1159 if (Chance16R(1, 14, r) && !indsp->random_sounds.empty() && _settings_client.sound.ambient) {
1160 if (std::any_of(std::begin(i->produced), std::end(i->produced), [](const auto &p) { return p.history[LAST_MONTH].production > 0; })) {
1161 /* Play sound since last month had production */
1162 SndPlayTileFx(
1163 static_cast<SoundFx>(indsp->random_sounds[((r >> 16) * indsp->random_sounds.size()) >> 16]),
1164 i->location.tile);
1165 }
1166 }
1167 }
1168
1169 i->counter--;
1170
1171 /* If using an industry callback, scale the callback interval by cargo scale percentage. */
1176 }
1177 }
1178
1179 /*
1180 * All other production and special effects happen every 256 ticks, and cargo production is just scaled by the cargo scale percentage.
1181 * 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.
1182 */
1183 if ((i->counter % Ticks::INDUSTRY_PRODUCE_TICKS) == 0) {
1184 /* Handle non-callback cargo production. */
1186
1187 IndustryBehaviours indbehav = indsp->behaviour;
1188
1189 if (indbehav.Test(IndustryBehaviour::PlantFields)) {
1190 uint16_t cb_res = CALLBACK_FAILED;
1193 }
1194
1195 bool plant;
1196 if (cb_res != CALLBACK_FAILED) {
1198 } else {
1199 plant = Chance16(1, 8);
1200 }
1201
1202 if (plant) PlantRandomFarmField(i);
1203 }
1204 if (indbehav.Test(IndustryBehaviour::CutTrees)) {
1205 uint16_t cb_res = CALLBACK_FAILED;
1208 }
1209
1210 bool cut;
1211 if (cb_res != CALLBACK_FAILED) {
1213 } else {
1214 cut = ((i->counter % Ticks::INDUSTRY_CUT_TREE_TICKS) == 0);
1215 }
1216
1217 if (cut) ChopLumberMillTrees(i);
1218 }
1219
1221 TriggerIndustryAnimation(i, IndustryAnimationTrigger::IndustryTick);
1222 }
1223}
1224
1225void OnTick_Industry()
1226{
1227 if (_industry_sound_ctr != 0) {
1228 _industry_sound_ctr++;
1229
1230 if (_industry_sound_ctr == 75) {
1231 if (_settings_client.sound.ambient) SndPlayTileFx(SND_37_LUMBER_MILL_2, _industry_sound_tile);
1232 } else if (_industry_sound_ctr == 160) {
1233 _industry_sound_ctr = 0;
1234 if (_settings_client.sound.ambient) SndPlayTileFx(SND_36_LUMBER_MILL_3, _industry_sound_tile);
1235 }
1236 }
1237
1238 if (_game_mode == GM_EDITOR) return;
1239
1240 for (Industry *i : Industry::Iterate()) {
1241 ProduceIndustryGoods(i);
1242
1243 if ((TimerGameTick::counter + i->index) % Ticks::DAY_TICKS == 0) {
1244 for (auto &a : i->accepted) a.accumulated_waiting += a.waiting;
1245 }
1246 }
1247}
1248
1254{
1255 return CommandCost();
1256}
1257
1264{
1265 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) {
1266 if (GetTileZ(tile) < HighestSnowLine() + 2) {
1267 return CommandCost(STR_ERROR_FOREST_CAN_ONLY_BE_PLANTED);
1268 }
1269 }
1270 return CommandCost();
1271}
1272
1280static bool CheckScaledDistanceFromEdge(TileIndex tile, uint maxdist)
1281{
1282 uint maxdist_x = maxdist;
1283 uint maxdist_y = maxdist;
1284
1285 if (Map::SizeX() > 256) maxdist_x *= Map::SizeX() / 256;
1286 if (Map::SizeY() > 256) maxdist_y *= Map::SizeY() / 256;
1287
1288 if (DistanceFromEdgeDir(tile, DIAGDIR_NE) < maxdist_x) return true;
1289 if (DistanceFromEdgeDir(tile, DIAGDIR_NW) < maxdist_y) return true;
1290 if (DistanceFromEdgeDir(tile, DIAGDIR_SW) < maxdist_x) return true;
1291 if (DistanceFromEdgeDir(tile, DIAGDIR_SE) < maxdist_y) return true;
1292
1293 return false;
1294}
1295
1302{
1303 if (_game_mode == GM_EDITOR) return CommandCost();
1304
1306
1307 return CommandCost(STR_ERROR_CAN_ONLY_BE_POSITIONED);
1308}
1309
1310extern bool _ignore_industry_restrictions;
1311
1318{
1319 if (_game_mode == GM_EDITOR && _ignore_industry_restrictions) return CommandCost();
1320
1321 if (TileHeight(tile) == 0 &&
1323
1324 return CommandCost(STR_ERROR_CAN_ONLY_BE_POSITIONED);
1325}
1326
1333{
1334 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) {
1335 if (GetTileZ(tile) + 2 >= HighestSnowLine()) {
1336 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1337 }
1338 }
1339 return CommandCost();
1340}
1341
1348{
1349 if (GetTropicZone(tile) == TROPICZONE_DESERT) {
1350 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1351 }
1352 return CommandCost();
1353}
1354
1361{
1362 if (GetTropicZone(tile) != TROPICZONE_DESERT) {
1363 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_DESERT);
1364 }
1365 return CommandCost();
1366}
1367
1374{
1375 if (GetTropicZone(tile) != TROPICZONE_RAINFOREST) {
1376 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_RAINFOREST);
1377 }
1378 return CommandCost();
1379}
1380
1387{
1388 if (GetTileZ(tile) > 4) {
1389 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_LOW_AREAS);
1390 }
1391 return CommandCost();
1392}
1393
1400
1413
1424static CommandCost FindTownForIndustry(TileIndex tile, IndustryType type, Town **t)
1425{
1426 *t = ClosestTownFromTile(tile, UINT_MAX);
1427
1429
1430 for (const IndustryID &industry : Industry::industries[type]) {
1431 if (Industry::Get(industry)->town == *t) {
1432 *t = nullptr;
1433 return CommandCost(STR_ERROR_ONLY_ONE_ALLOWED_PER_TOWN);
1434 }
1435 }
1436
1437 return CommandCost();
1438}
1439
1440bool IsSlopeRefused(Slope current, Slope refused)
1441{
1442 if (IsSteepSlope(current)) return true;
1443 if (current != SLOPE_FLAT) {
1444 if (IsSteepSlope(refused)) return true;
1445
1446 Slope t = ComplementSlope(current);
1447
1448 if ((refused & SLOPE_W) && (t & SLOPE_NW)) return true;
1449 if ((refused & SLOPE_S) && (t & SLOPE_NE)) return true;
1450 if ((refused & SLOPE_E) && (t & SLOPE_SW)) return true;
1451 if ((refused & SLOPE_N) && (t & SLOPE_SE)) return true;
1452 }
1453
1454 return false;
1455}
1456
1464static CommandCost CheckIfIndustryTilesAreFree(TileIndex tile, const IndustryTileLayout &layout, IndustryType type)
1465{
1466 IndustryBehaviours ind_behav = GetIndustrySpec(type)->behaviour;
1467
1468 for (const IndustryTileLayoutTile &it : layout) {
1469 IndustryGfx gfx = GetTranslatedIndustryTileID(it.gfx);
1470 TileIndex cur_tile = TileAddWrap(tile, it.ti.x, it.ti.y);
1471
1472 if (!IsValidTile(cur_tile)) {
1473 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1474 }
1475
1476 if (gfx == GFX_WATERTILE_SPECIALCHECK) {
1477 if (!IsWaterTile(cur_tile) ||
1478 !IsTileFlat(cur_tile)) {
1479 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1480 }
1481 } else {
1482 CommandCost ret = EnsureNoVehicleOnGround(cur_tile);
1483 if (ret.Failed()) return ret;
1484 if (IsBridgeAbove(cur_tile)) return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1485
1486 const IndustryTileSpec *its = GetIndustryTileSpec(gfx);
1487
1488 /* Perform land/water check if not disabled */
1489 if (!HasBit(its->slopes_refused, 5) && ((HasTileWaterClass(cur_tile) && IsTileOnWater(cur_tile)) != ind_behav.Test(IndustryBehaviour::BuiltOnWater))) return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1490
1491 if (ind_behav.Any({IndustryBehaviour::OnlyInTown, IndustryBehaviour::Town1200More}) || // Tile must be a house
1492 (ind_behav.Test(IndustryBehaviour::OnlyNearTown) && IsTileType(cur_tile, MP_HOUSE))) { // Tile is allowed to be a house (and it is a house)
1493 if (!IsTileType(cur_tile, MP_HOUSE)) {
1494 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_TOWNS);
1495 }
1496
1497 /* Clear the tiles as OWNER_TOWN to not affect town rating, and to not clear protected buildings */
1499 ret = Command<CMD_LANDSCAPE_CLEAR>::Do({}, cur_tile);
1500 cur_company.Restore();
1501
1502 if (ret.Failed()) return ret;
1503 } else {
1504 /* Clear the tiles, but do not affect town ratings */
1506 if (ret.Failed()) return ret;
1507 }
1508 }
1509 }
1510
1511 return CommandCost();
1512}
1513
1526static 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)
1527{
1528 bool refused_slope = false;
1529 bool custom_shape = false;
1530
1531 for (const IndustryTileLayoutTile &it : layout) {
1532 IndustryGfx gfx = GetTranslatedIndustryTileID(it.gfx);
1533 TileIndex cur_tile = TileAddWrap(tile, it.ti.x, it.ti.y);
1534 assert(IsValidTile(cur_tile)); // checked before in CheckIfIndustryTilesAreFree
1535
1536 if (gfx != GFX_WATERTILE_SPECIALCHECK) {
1537 const IndustryTileSpec *its = GetIndustryTileSpec(gfx);
1538
1540 custom_shape = true;
1541 CommandCost ret = PerformIndustryTileSlopeCheck(tile, cur_tile, its, type, gfx, layout_index, initial_random_bits, founder, creation_type);
1542 if (ret.Failed()) return ret;
1543 } else {
1544 Slope tileh = GetTileSlope(cur_tile);
1545 refused_slope |= IsSlopeRefused(tileh, its->slopes_refused);
1546 }
1547 }
1548 }
1549
1550 if (custom_shape_check != nullptr) *custom_shape_check = custom_shape;
1551
1552 /* It is almost impossible to have a fully flat land in TG, so what we
1553 * do is that we check if we can make the land flat later on. See
1554 * CheckIfCanLevelIndustryPlatform(). */
1555 if (!refused_slope || (_settings_game.game_creation.land_generator == LG_TERRAGENESIS && _generating_world && !custom_shape && !_ignore_industry_restrictions)) {
1556 return CommandCost();
1557 }
1558 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1559}
1560
1568static CommandCost CheckIfIndustryIsAllowed(TileIndex tile, IndustryType type, const Town *t)
1569{
1570 if (GetIndustrySpec(type)->behaviour.Test(IndustryBehaviour::Town1200More) && t->cache.population < 1200) {
1571 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_TOWNS_WITH_POPULATION_OF_1200);
1572 }
1573
1574 if (GetIndustrySpec(type)->behaviour.Test(IndustryBehaviour::OnlyNearTown) && DistanceMax(t->xy, tile) > 9) {
1575 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_NEAR_TOWN_CENTER);
1576 }
1577
1578 return CommandCost();
1579}
1580
1581static bool CheckCanTerraformSurroundingTiles(TileIndex tile, uint height, int internal)
1582{
1583 /* Check if we don't leave the map */
1584 if (TileX(tile) == 0 || TileY(tile) == 0 || GetTileType(tile) == MP_VOID) return false;
1585
1586 TileArea ta(tile - TileDiffXY(1, 1), 2, 2);
1587 for (TileIndex tile_walk : ta) {
1588 uint curh = TileHeight(tile_walk);
1589 /* Is the tile clear? */
1590 if ((GetTileType(tile_walk) != MP_CLEAR) && (GetTileType(tile_walk) != MP_TREES)) return false;
1591
1592 /* Don't allow too big of a change if this is the sub-tile check */
1593 if (internal != 0 && Delta(curh, height) > 1) return false;
1594
1595 /* Different height, so the surrounding tiles of this tile
1596 * has to be correct too (in level, or almost in level)
1597 * else you get a chain-reaction of terraforming. */
1598 if (internal == 0 && curh != height) {
1599 if (TileX(tile_walk) == 0 || TileY(tile_walk) == 0 || !CheckCanTerraformSurroundingTiles(tile_walk + TileDiffXY(-1, -1), height, internal + 1)) {
1600 return false;
1601 }
1602 }
1603 }
1604
1605 return true;
1606}
1607
1613{
1614 int max_x = 0;
1615 int max_y = 0;
1616
1617 /* Finds dimensions of largest variant of this industry */
1618 for (const IndustryTileLayoutTile &it : layout) {
1619 if (it.gfx == GFX_WATERTILE_SPECIALCHECK) continue; // watercheck tiles don't count for footprint size
1620 if (it.ti.x > max_x) max_x = it.ti.x;
1621 if (it.ti.y > max_y) max_y = it.ti.y;
1622 }
1623
1624 /* Remember level height */
1625 uint h = TileHeight(tile);
1626
1628 /* Check that all tiles in area and surrounding are clear
1629 * this determines that there are no obstructing items */
1630
1631 /* TileArea::Expand is not used here as we need to abort
1632 * instead of clamping if the bounds cannot expanded. */
1635
1636 if (TileX(ta.tile) + ta.w >= Map::MaxX() || TileY(ta.tile) + ta.h >= Map::MaxY()) return false;
1637
1638 /* _current_company is OWNER_NONE for randomly generated industries and in editor, or the company who funded or prospected the industry.
1639 * Perform terraforming as OWNER_TOWN to disable autoslope and town ratings. */
1641
1642 for (TileIndex tile_walk : ta) {
1643 uint curh = TileHeight(tile_walk);
1644 if (curh != h) {
1645 /* This tile needs terraforming. Check if we can do that without
1646 * damaging the surroundings too much. */
1647 if (!CheckCanTerraformSurroundingTiles(tile_walk, h, 0)) {
1648 cur_company.Restore();
1649 return false;
1650 }
1651 /* This is not 100% correct check, but the best we can do without modifying the map.
1652 * What is missing, is if the difference in height is more than 1.. */
1653 if (std::get<0>(Command<CMD_TERRAFORM_LAND>::Do(DoCommandFlags{flags}.Reset(DoCommandFlag::Execute), tile_walk, SLOPE_N, curh <= h)).Failed()) {
1654 cur_company.Restore();
1655 return false;
1656 }
1657 }
1658 }
1659
1660 if (flags.Test(DoCommandFlag::Execute)) {
1661 /* Terraform the land under the industry */
1662 for (TileIndex tile_walk : ta) {
1663 uint curh = TileHeight(tile_walk);
1664 while (curh != h) {
1665 /* We give the terraforming for free here, because we can't calculate
1666 * exact cost in the test-round, and as we all know, that will cause
1667 * a nice assert if they don't match ;) */
1668 Command<CMD_TERRAFORM_LAND>::Do(flags, tile_walk, SLOPE_N, curh <= h);
1669 curh += (curh > h) ? -1 : 1;
1670 }
1671 }
1672 }
1673
1674 cur_company.Restore();
1675 return true;
1676}
1677
1678
1686{
1687 const IndustrySpec *indspec = GetIndustrySpec(type);
1688
1689 for (IndustryType conflicting_type : indspec->conflicting) {
1690 if (conflicting_type == IT_INVALID) continue;
1691
1692 for (const IndustryID &industry : Industry::industries[conflicting_type]) {
1693 /* Within 14 tiles from another industry is considered close */
1694 if (DistanceMax(tile, Industry::Get(industry)->location.tile) > 14) continue;
1695
1696 return CommandCost(STR_ERROR_INDUSTRY_TOO_CLOSE);
1697 }
1698 }
1699 return CommandCost();
1700}
1701
1706static void AdvertiseIndustryOpening(const Industry *ind)
1707{
1708 const IndustrySpec *ind_spc = GetIndustrySpec(ind->type);
1709 EncodedString headline;
1710 if (ind_spc->new_industry_text > STR_LAST_STRINGID) {
1711 headline = GetEncodedString(ind_spc->new_industry_text, ind_spc->name, STR_TOWN_NAME, ind->town->index);
1712 } else {
1713 headline = GetEncodedString(ind_spc->new_industry_text, ind_spc->name, ind->town->index);
1714 }
1715 AddIndustryNewsItem(std::move(headline), NewsType::IndustryOpen, ind->index);
1716 AI::BroadcastNewEvent(new ScriptEventIndustryOpen(ind->index));
1717 Game::NewEvent(new ScriptEventIndustryOpen(ind->index));
1718}
1719
1726{
1728 /* Industry has a neutral station. Use it and ignore any other nearby stations. */
1729 ind->stations_near.insert(ind->neutral_station);
1730 ind->neutral_station->industries_near.clear();
1732 return;
1733 }
1734
1735 ForAllStationsAroundTiles(ind->location, [ind](Station *st, TileIndex tile) {
1736 if (!IsTileType(tile, MP_INDUSTRY) || GetIndustryIndex(tile) != ind->index) return false;
1737 ind->stations_near.insert(st);
1738 st->AddIndustryToDeliver(ind, tile);
1739 return false;
1740 });
1741}
1742
1754static void DoCreateNewIndustry(Industry *i, TileIndex tile, IndustryType type, const IndustryTileLayout &layout, size_t layout_index, Town *t, Owner founder, uint16_t initial_random_bits)
1755{
1756 const IndustrySpec *indspec = GetIndustrySpec(type);
1757
1758 i->location = TileArea(tile, 1, 1);
1759 i->type = type;
1760
1761 auto &industries = Industry::industries[type];
1762 industries.insert(i->index);
1763
1764 for (size_t index = 0; index < std::size(indspec->produced_cargo); ++index) {
1765 if (!IsValidCargoType(indspec->produced_cargo[index])) break;
1766
1767 Industry::ProducedCargo &p = i->produced.emplace_back();
1768 p.cargo = indspec->produced_cargo[index];
1769 p.rate = indspec->production_rate[index];
1770 }
1771
1772 for (size_t index = 0; index < std::size(indspec->accepts_cargo); ++index) {
1773 if (!IsValidCargoType(indspec->accepts_cargo[index])) break;
1774
1775 Industry::AcceptedCargo &a = i->accepted.emplace_back();
1776 a.cargo = indspec->accepts_cargo[index];
1777 }
1778
1779 /* Randomize initial production if non-original economy is used and there are no production related callbacks. */
1780 if (!indspec->UsesOriginalEconomy()) {
1781 for (auto &p : i->produced) {
1782 p.rate = ClampTo<uint8_t>((RandomRange(256) + 128) * p.rate >> 8);
1783 }
1784 }
1785
1786 i->town = t;
1787 i->owner = OWNER_NONE;
1788
1789 uint16_t r = Random();
1790 i->random_colour = static_cast<Colours>(GB(r, 0, 4));
1791 i->counter = GB(r, 4, 12);
1792 i->random = initial_random_bits;
1793 i->was_cargo_delivered = false;
1795 i->founder = founder;
1796 i->ctlflags = {};
1797
1799 i->construction_type = (_game_mode == GM_EDITOR) ? ICT_SCENARIO_EDITOR :
1801
1802 /* Adding 1 here makes it conform to specs of var44 of varaction2 for industries
1803 * 0 = created prior of newindustries
1804 * else, chosen layout + 1 */
1805 i->selected_layout = (uint8_t)(layout_index + 1);
1806
1809
1811
1812 /* Call callbacks after the regular fields got initialised. */
1813
1816 if (res != CALLBACK_FAILED) {
1817 if (res < PRODLEVEL_MINIMUM || res > PRODLEVEL_MAXIMUM) {
1819 } else {
1820 i->prod_level = res;
1822 }
1823 }
1824 }
1825
1826 if (_generating_world) {
1829 for (auto &p : i->produced) {
1830 p.history[LAST_MONTH].production = ScaleByCargoScale(p.waiting * 8, false);
1831 p.waiting = 0;
1832 }
1833 }
1834
1835 for (auto &p : i->produced) {
1836 p.history[LAST_MONTH].production += ScaleByCargoScale(p.rate * 8, false);
1837 }
1838
1840 }
1841
1843 uint16_t res = GetIndustryCallback(CBID_INDUSTRY_DECIDE_COLOUR, 0, 0, i, type, INVALID_TILE);
1844 if (res != CALLBACK_FAILED) {
1845 if (GB(res, 4, 11) != 0) ErrorUnknownCallbackResult(indspec->grf_prop.grfid, CBID_INDUSTRY_DECIDE_COLOUR, res);
1846 i->random_colour = static_cast<Colours>(GB(res, 0, 4));
1847 }
1848 }
1849
1851 /* Clear all input cargo types */
1852 i->accepted.clear();
1853 /* Query actual types */
1855 for (uint j = 0; j < maxcargoes; j++) {
1857 if (res == CALLBACK_FAILED || GB(res, 0, 8) == UINT8_MAX) break;
1858 if (indspec->grf_prop.grffile->grf_version >= 8 && res >= 0x100) {
1860 break;
1861 }
1862 CargoType cargo = GetCargoTranslation(GB(res, 0, 8), indspec->grf_prop.grffile);
1863 /* Industries without "unlimited" cargo types support depend on the specific order/slots of cargo types.
1864 * They need to be able to blank out specific slots without aborting the callback sequence,
1865 * and solve this by returning undefined cargo indexes. Skip these. */
1867 /* As slots are allocated as needed now, this means we do need to add a slot for the invalid cargo. */
1868 Industry::AcceptedCargo &a = i->accepted.emplace_back();
1869 a.cargo = INVALID_CARGO;
1870 continue;
1871 }
1872 /* Verify valid cargo */
1873 if (std::ranges::find(indspec->accepts_cargo, cargo) == std::end(indspec->accepts_cargo)) {
1874 /* Cargo not in spec, error in NewGRF */
1876 break;
1877 }
1878 if (std::any_of(std::begin(i->accepted), std::begin(i->accepted) + j, [&cargo](const auto &a) { return a.cargo == cargo; })) {
1879 /* Duplicate cargo */
1881 break;
1882 }
1883 Industry::AcceptedCargo &a = i->accepted.emplace_back();
1884 a.cargo = cargo;
1885 }
1886 }
1887
1889 /* Clear all output cargo types */
1890 i->produced.clear();
1891 /* Query actual types */
1893 for (uint j = 0; j < maxcargoes; j++) {
1895 if (res == CALLBACK_FAILED || GB(res, 0, 8) == UINT8_MAX) break;
1896 if (indspec->grf_prop.grffile->grf_version >= 8 && res >= 0x100) {
1898 break;
1899 }
1900 CargoType cargo = GetCargoTranslation(GB(res, 0, 8), indspec->grf_prop.grffile);
1901 /* Allow older GRFs to skip slots. */
1903 /* As slots are allocated as needed now, this means we do need to add a slot for the invalid cargo. */
1904 Industry::ProducedCargo &p = i->produced.emplace_back();
1905 p.cargo = INVALID_CARGO;
1906 continue;
1907 }
1908 /* Verify valid cargo */
1909 if (std::ranges::find(indspec->produced_cargo, cargo) == std::end(indspec->produced_cargo)) {
1910 /* Cargo not in spec, error in NewGRF */
1912 break;
1913 }
1914 if (std::any_of(std::begin(i->produced), std::begin(i->produced) + j, [&cargo](const auto &p) { return p.cargo == cargo; })) {
1915 /* Duplicate cargo */
1917 break;
1918 }
1919 Industry::ProducedCargo &p = i->produced.emplace_back();
1920 p.cargo = cargo;
1921 }
1922 }
1923
1924 /* Plant the tiles */
1925
1926 for (const IndustryTileLayoutTile &it : layout) {
1927 TileIndex cur_tile = tile + ToTileIndexDiff(it.ti);
1928
1929 if (it.gfx != GFX_WATERTILE_SPECIALCHECK) {
1930 i->location.Add(cur_tile);
1931
1932 WaterClass wc = (IsWaterTile(cur_tile) ? GetWaterClass(cur_tile) : WATER_CLASS_INVALID);
1933
1935
1936 MakeIndustry(cur_tile, i->index, it.gfx, Random(), wc);
1937
1938 if (_generating_world) {
1939 SetIndustryConstructionCounter(cur_tile, 3);
1940 SetIndustryConstructionStage(cur_tile, 2);
1941 }
1942
1943 /* it->gfx is stored in the map. But the translated ID cur_gfx is the interesting one */
1944 IndustryGfx cur_gfx = GetTranslatedIndustryTileID(it.gfx);
1945 const IndustryTileSpec *its = GetIndustryTileSpec(cur_gfx);
1946 if (its->animation.status != AnimationStatus::NoAnimation) AddAnimatedTile(cur_tile);
1947 }
1948 }
1949
1950 /* Call callbacks after all tiles have been created. */
1951 for (TileIndex cur_tile : i->location) {
1952 if (i->TileBelongsToIndustry(cur_tile)) {
1953 /* There are no shared random bits, consistent with "MakeIndustryTileBigger" in tile loop.
1954 * So, trigger tiles individually */
1955 TriggerIndustryTileAnimation_ConstructionStageChanged(cur_tile, true);
1956 }
1957 }
1958
1960 for (uint j = 0; j != 50; j++) PlantRandomFarmField(i);
1961 }
1962 InvalidateWindowData(WC_INDUSTRY_DIRECTORY, 0, IDIWD_FORCE_REBUILD);
1964
1966}
1967
1984static 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)
1985{
1986 assert(layout_index < indspec->layouts.size());
1987 const IndustryTileLayout &layout = indspec->layouts[layout_index];
1988
1989 *ip = nullptr;
1990
1991 /* 1. Cheap: Built-in checks on industry level. */
1993 if (ret.Failed()) return ret;
1994
1995 Town *t = nullptr;
1996 ret = FindTownForIndustry(tile, type, &t);
1997 if (ret.Failed()) return ret;
1998 assert(t != nullptr);
1999
2000 ret = CheckIfIndustryIsAllowed(tile, type, t);
2001 if (ret.Failed()) return ret;
2002
2003 /* 2. Built-in checks on industry tiles. */
2004 std::vector<ClearedObjectArea> object_areas(_cleared_object_areas);
2005 ret = CheckIfIndustryTilesAreFree(tile, layout, type);
2006 _cleared_object_areas = std::move(object_areas);
2007 if (ret.Failed()) return ret;
2008
2009 /* 3. NewGRF-defined checks on industry level. */
2010 if (GetIndustrySpec(type)->callback_mask.Test(IndustryCallbackMask::Location)) {
2011 ret = CheckIfCallBackAllowsCreation(tile, type, layout_index, random_var8f, random_initial_bits, founder, creation_type);
2012 } else {
2013 ret = _check_new_industry_procs[indspec->check_proc](tile);
2014 }
2015 if (ret.Failed()) return ret;
2016
2017 /* 4. Expensive: NewGRF-defined checks on industry tiles. */
2018 bool custom_shape_check = false;
2019 ret = CheckIfIndustryTileSlopes(tile, layout, layout_index, type, random_initial_bits, founder, creation_type, &custom_shape_check);
2020 if (ret.Failed()) return ret;
2021
2023 !_ignore_industry_restrictions && !CheckIfCanLevelIndustryPlatform(tile, DoCommandFlag::NoWater, layout)) {
2024 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
2025 }
2026
2027 if (!Industry::CanAllocateItem()) return CommandCost(STR_ERROR_TOO_MANY_INDUSTRIES);
2028
2029 if (flags.Test(DoCommandFlag::Execute)) {
2030 *ip = new Industry(tile);
2031 if (!custom_shape_check) CheckIfCanLevelIndustryPlatform(tile, {DoCommandFlag::NoWater, DoCommandFlag::Execute}, layout);
2032 DoCreateNewIndustry(*ip, tile, type, layout, layout_index, t, founder, random_initial_bits);
2033 }
2034
2035 return CommandCost();
2036}
2037
2048CommandCost CmdBuildIndustry(DoCommandFlags flags, TileIndex tile, IndustryType it, uint32_t first_layout, bool fund, uint32_t seed)
2049{
2050 if (it >= NUM_INDUSTRYTYPES) return CMD_ERROR;
2051
2052 const IndustrySpec *indspec = GetIndustrySpec(it);
2053
2054 /* Check if the to-be built/founded industry is available for this climate. */
2055 if (!indspec->enabled || indspec->layouts.empty()) return CMD_ERROR;
2056
2057 /* If the setting for raw-material industries is not on, you cannot build raw-material industries.
2058 * Raw material industries are industries that do not accept cargo (at least for now) */
2059 if (_game_mode != GM_EDITOR && _current_company != OWNER_DEITY && _settings_game.construction.raw_industry_construction == 0 && indspec->IsRawIndustry()) {
2060 return CMD_ERROR;
2061 }
2062
2063 if (_game_mode != GM_EDITOR && GetIndustryProbabilityCallback(it, _current_company == OWNER_DEITY ? IACT_RANDOMCREATION : IACT_USERCREATION, 1) == 0) {
2064 return CMD_ERROR;
2065 }
2066
2067 Randomizer randomizer;
2068 randomizer.SetSeed(seed);
2069 uint16_t random_initial_bits = GB(seed, 0, 16);
2070 uint32_t random_var8f = randomizer.Next();
2071 size_t num_layouts = indspec->layouts.size();
2072 CommandCost ret = CommandCost(STR_ERROR_SITE_UNSUITABLE);
2073 const bool deity_prospect = _current_company == OWNER_DEITY && !fund;
2074
2075 Industry *ind = nullptr;
2076 if (deity_prospect || (_game_mode != GM_EDITOR && _current_company != OWNER_DEITY && _settings_game.construction.raw_industry_construction == 2 && indspec->IsRawIndustry())) {
2077 if (flags.Test(DoCommandFlag::Execute)) {
2078 /* Prospecting has a chance to fail, however we cannot guarantee that something can
2079 * be built on the map, so the chance gets lower when the map is fuller, but there
2080 * is nothing we can really do about that. */
2081 bool prospect_success = deity_prospect || Random() <= indspec->prospecting_chance;
2082 if (prospect_success) {
2083 /* Prospected industries are build as OWNER_TOWN to not e.g. be build on owned land of the founder */
2086 for (int i = 0; i < 5000; i++) {
2087 /* We should not have more than one Random() in a function call
2088 * because parameter evaluation order is not guaranteed in the c++ standard
2089 */
2090 tile = RandomTile();
2091 /* Start with a random layout */
2092 size_t layout = RandomRange((uint32_t)num_layouts);
2093 /* Check now each layout, starting with the random one */
2094 for (size_t j = 0; j < num_layouts; j++) {
2095 layout = (layout + 1) % num_layouts;
2096 ret = CreateNewIndustryHelper(tile, it, flags, indspec, layout, random_var8f, random_initial_bits, cur_company.GetOriginalValue(), calltype, &ind);
2097 if (ret.Succeeded()) break;
2098 }
2099 if (ret.Succeeded()) break;
2100 }
2101 cur_company.Restore();
2102 }
2103 if (ret.Failed() && IsLocalCompany()) {
2104 if (prospect_success) {
2105 ShowErrorMessage(GetEncodedString(STR_ERROR_CAN_T_PROSPECT_INDUSTRY), GetEncodedString(STR_ERROR_NO_SUITABLE_PLACES_FOR_PROSPECTING), WL_INFO);
2106 } else {
2107 ShowErrorMessage(GetEncodedString(STR_ERROR_CAN_T_PROSPECT_INDUSTRY), GetEncodedString(STR_ERROR_PROSPECTING_WAS_UNLUCKY), WL_INFO);
2108 }
2109 }
2110 }
2111 } else {
2112 size_t layout = first_layout;
2113 if (layout >= num_layouts) return CMD_ERROR;
2114
2115 /* Check subsequently each layout, starting with the given layout in p1 */
2116 for (size_t i = 0; i < num_layouts; i++) {
2117 layout = (layout + 1) % num_layouts;
2118 ret = CreateNewIndustryHelper(tile, it, flags, indspec, layout, random_var8f, random_initial_bits, _current_company, _current_company == OWNER_DEITY ? IACT_RANDOMCREATION : IACT_USERCREATION, &ind);
2119 if (ret.Succeeded()) break;
2120 }
2121
2122 /* If it still failed, there's no suitable layout to build here, return the error */
2123 if (ret.Failed()) return ret;
2124 }
2125
2126 if (flags.Test(DoCommandFlag::Execute) && ind != nullptr && _game_mode != GM_EDITOR) {
2128 }
2129
2131}
2132
2141{
2142 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2143
2144 Industry *ind = Industry::GetIfValid(ind_id);
2145 if (ind == nullptr) return CMD_ERROR;
2146 if (!ctlflags.IsValid()) return CMD_ERROR;
2147
2148 if (flags.Test(DoCommandFlag::Execute)) ind->ctlflags = ctlflags;
2149
2150 return CommandCost();
2151}
2152
2162CommandCost CmdIndustrySetProduction(DoCommandFlags flags, IndustryID ind_id, uint8_t prod_level, bool show_news, const EncodedString &custom_news)
2163{
2164 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2165 if (prod_level < PRODLEVEL_MINIMUM || prod_level > PRODLEVEL_MAXIMUM) return CMD_ERROR;
2166
2167 Industry *ind = Industry::GetIfValid(ind_id);
2168 if (ind == nullptr) return CMD_ERROR;
2169
2170 if (flags.Test(DoCommandFlag::Execute)) {
2172 ind->prod_level = prod_level;
2174
2175 /* Show news message if requested. */
2176 if (show_news && prod_level != ind->prod_level) {
2177 NewsType nt;
2178 switch (WhoCanServiceIndustry(ind)) {
2179 case 0: nt = NewsType::IndustryNobody; break;
2180 case 1: nt = NewsType::IndustryOther; break;
2181 case 2: nt = NewsType::IndustryCompany; break;
2182 default: NOT_REACHED();
2183 }
2184
2185 /* Set parameters of news string */
2186 EncodedString headline;
2187 if (!custom_news.empty()) {
2188 headline = custom_news;
2189 } else {
2190 StringID str = (prod_level > ind->prod_level)
2193
2194 if (str > STR_LAST_STRINGID) {
2195 headline = GetEncodedString(str, STR_TOWN_NAME, ind->town->index, GetIndustrySpec(ind->type)->name);
2196 } else {
2197 headline = GetEncodedString(str, ind->index);
2198 }
2199 }
2200
2201 AddIndustryNewsItem(std::move(headline), nt, ind->index);
2202 }
2203 }
2204
2205 return CommandCost();
2206}
2207
2218{
2219 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2220
2221 Industry *ind = Industry::GetIfValid(ind_id);
2222 if (ind == nullptr) return CMD_ERROR;
2223
2224 if (company_id != OWNER_NONE && company_id != INVALID_OWNER && company_id != OWNER_DEITY
2225 && !Company::IsValidID(company_id)) return CMD_ERROR;
2226
2227 if (flags.Test(DoCommandFlag::Execute)) {
2228 if (consumer) {
2229 ind->exclusive_consumer = company_id;
2230 } else {
2231 ind->exclusive_supplier = company_id;
2232 }
2233 }
2234
2235
2236 return CommandCost();
2237}
2238
2247{
2248 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2249
2250 Industry *ind = Industry::GetIfValid(ind_id);
2251 if (ind == nullptr) return CMD_ERROR;
2252
2253 if (flags.Test(DoCommandFlag::Execute)) {
2254 ind->text.clear();
2255 if (!text.empty()) ind->text = text;
2257 }
2258
2259 return CommandCost();
2260}
2261
2269static Industry *CreateNewIndustry(TileIndex tile, IndustryType type, IndustryAvailabilityCallType creation_type)
2270{
2271 const IndustrySpec *indspec = GetIndustrySpec(type);
2272
2273 uint32_t seed = Random();
2274 uint32_t seed2 = Random();
2275 Industry *i = nullptr;
2276 size_t layout_index = RandomRange((uint32_t)indspec->layouts.size());
2277 [[maybe_unused]] CommandCost ret = CreateNewIndustryHelper(tile, type, DoCommandFlag::Execute, indspec, layout_index, seed, GB(seed2, 0, 16), OWNER_NONE, creation_type, &i);
2278 assert(i != nullptr || ret.Failed());
2279 return i;
2280}
2281
2288static uint32_t GetScaledIndustryGenerationProbability(IndustryType it, bool *force_at_least_one)
2289{
2290 const IndustrySpec *ind_spc = GetIndustrySpec(it);
2292 if (!ind_spc->enabled || ind_spc->layouts.empty() ||
2293 (_game_mode != GM_EDITOR && _settings_game.difficulty.industry_density == ID_FUND_ONLY) ||
2294 (chance = GetIndustryProbabilityCallback(it, IACT_MAPGENERATION, chance)) == 0) {
2295 *force_at_least_one = false;
2296 return 0;
2297 } else {
2298 chance *= 16; // to increase precision
2299 /* We want industries appearing at coast to appear less often on bigger maps, as length of coast increases slower than map area.
2300 * For simplicity we scale in both cases, though scaling the probabilities of all industries has no effect. */
2301 chance = (ind_spc->check_proc == CHECK_REFINERY || ind_spc->check_proc == CHECK_OIL_RIG) ? Map::ScaleBySize1D(chance) : Map::ScaleBySize(chance);
2302
2303 *force_at_least_one = (chance > 0) && !ind_spc->behaviour.Test(IndustryBehaviour::NoBuildMapCreation) && (_game_mode != GM_EDITOR);
2304 return chance;
2305 }
2306}
2307
2314static uint16_t GetIndustryGamePlayProbability(IndustryType it, uint8_t *min_number)
2315{
2317 *min_number = 0;
2318 return 0;
2319 }
2320
2321 const IndustrySpec *ind_spc = GetIndustrySpec(it);
2323 if (!ind_spc->enabled || ind_spc->layouts.empty() ||
2326 (chance = GetIndustryProbabilityCallback(it, IACT_RANDOMCREATION, chance)) == 0) {
2327 *min_number = 0;
2328 return 0;
2329 }
2330 *min_number = ind_spc->behaviour.Test(IndustryBehaviour::CanCloseLastInstance) ? 1 : 0;
2331 return chance;
2332}
2333
2339{
2340 /* Number of industries on a 256x256 map. */
2341 static const uint16_t numof_industry_table[] = {
2342 0, // none
2343 0, // minimal
2344 10, // very low
2345 25, // low
2346 55, // normal
2347 80, // high
2348 0, // custom
2349 };
2350
2351 assert(lengthof(numof_industry_table) == ID_END);
2352 uint difficulty = (_game_mode != GM_EDITOR) ? _settings_game.difficulty.industry_density : (uint)ID_VERY_LOW;
2353
2354 if (difficulty == ID_CUSTOM) return std::min<uint>(IndustryPool::MAX_SIZE, _settings_game.game_creation.custom_industry_number);
2355
2356 return std::min<uint>(IndustryPool::MAX_SIZE, Map::ScaleBySize(numof_industry_table[difficulty]));
2357}
2358
2367static Industry *PlaceIndustry(IndustryType type, IndustryAvailabilityCallType creation_type, bool try_hard)
2368{
2369 uint tries = try_hard ? 10000u : 2000u;
2370 for (; tries > 0; tries--) {
2371 Industry *ind = CreateNewIndustry(RandomTile(), type, creation_type);
2372 if (ind != nullptr) return ind;
2373 }
2374 return nullptr;
2375}
2376
2382static void PlaceInitialIndustry(IndustryType type, bool try_hard)
2383{
2385
2387 PlaceIndustry(type, IACT_MAPGENERATION, try_hard);
2388
2389 cur_company.Restore();
2390}
2391
2397{
2398 uint total = 0;
2399 for (const auto &industries : Industry::industries) {
2400 total += static_cast<uint16_t>(std::size(industries));
2401 }
2402 return total;
2403}
2404
2405
2408{
2409 this->probability = 0;
2410 this->min_number = 0;
2411 this->target_count = 0;
2412 this->max_wait = 1;
2413 this->wait_count = 0;
2414}
2415
2418{
2420
2421 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2422 this->builddata[it].Reset();
2423 }
2424}
2425
2428{
2429 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.
2430 if (_settings_game.difficulty.industry_density == ID_FUND_ONLY) return; // 'no industries' setting.
2431
2432 /* To prevent running out of unused industries for the player to connect,
2433 * add a fraction of new industries each month, but only if the manager can keep up. */
2434 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).
2435 if (GetCurrentTotalNumberOfIndustries() + max_behind >= (this->wanted_inds >> 16)) {
2436 this->wanted_inds += Map::ScaleBySize(NEWINDS_PER_MONTH);
2437 }
2438}
2439
2445{
2446 if (_game_mode != GM_EDITOR && _settings_game.difficulty.industry_density == ID_FUND_ONLY) return; // No industries in the game.
2447
2448 uint32_t industry_probs[NUM_INDUSTRYTYPES];
2449 bool force_at_least_one[NUM_INDUSTRYTYPES];
2450 uint32_t total_prob = 0;
2451 uint num_forced = 0;
2452
2453 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2454 industry_probs[it] = GetScaledIndustryGenerationProbability(it, force_at_least_one + it);
2455 total_prob += industry_probs[it];
2456 if (force_at_least_one[it]) num_forced++;
2457 }
2458
2459 uint total_amount = GetNumberOfIndustries();
2460 if (total_prob == 0 || total_amount < num_forced) {
2461 /* Only place the forced ones */
2462 total_amount = num_forced;
2463 }
2464
2466
2467 /* Try to build one industry per type independent of any probabilities */
2468 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2469 if (force_at_least_one[it]) {
2470 assert(total_amount > 0);
2471 total_amount--;
2472 PlaceInitialIndustry(it, true);
2473 }
2474 }
2475
2476 /* Add the remaining industries according to their probabilities */
2477 for (uint i = 0; i < total_amount; i++) {
2478 uint32_t r = RandomRange(total_prob);
2479 IndustryType it = 0;
2480 while (r >= industry_probs[it]) {
2481 r -= industry_probs[it];
2482 it++;
2483 assert(it < NUM_INDUSTRYTYPES);
2484 }
2485 assert(industry_probs[it] > 0);
2486 PlaceInitialIndustry(it, false);
2487 }
2489}
2490
2491template <>
2492Industry::ProducedHistory SumHistory(std::span<const Industry::ProducedHistory> history)
2493{
2494 uint32_t production = std::accumulate(std::begin(history), std::end(history), 0, [](uint32_t r, const auto &p) { return r + p.production; });
2495 uint32_t transported = std::accumulate(std::begin(history), std::end(history), 0, [](uint32_t r, const auto &p) { return r + p.transported; });
2496 auto count = std::size(history);
2497 return {.production = ClampTo<uint16_t>(production / count), .transported = ClampTo<uint16_t>(transported / count)};
2498}
2499
2500template <>
2501Industry::AcceptedHistory SumHistory(std::span<const Industry::AcceptedHistory> history)
2502{
2503 uint32_t accepted = std::accumulate(std::begin(history), std::end(history), 0, [](uint32_t r, const auto &a) { return r + a.accepted; });
2504 uint32_t waiting = std::accumulate(std::begin(history), std::end(history), 0, [](uint32_t r, const auto &a) { return r + a.waiting; });;
2505 auto count = std::size(history);
2506 return {.accepted = ClampTo<uint16_t>(accepted / count), .waiting = ClampTo<uint16_t>(waiting / count)};
2507}
2508
2514{
2515 auto month = TimerGameEconomy::month;
2516 UpdateValidHistory(i->valid_history, HISTORY_YEAR, month);
2517
2518 for (auto &p : i->produced) {
2519 if (IsValidCargoType(p.cargo)) {
2520 if (p.history[THIS_MONTH].production != 0) i->last_prod_year = TimerGameEconomy::year;
2521
2522 RotateHistory(p.history, i->valid_history, HISTORY_YEAR, month);
2523 }
2524 }
2525
2526 for (auto &a : i->accepted) {
2527 if (!IsValidCargoType(a.cargo)) continue;
2528 if (a.history == nullptr) continue;
2529
2530 (*a.history)[THIS_MONTH].waiting = GetAndResetAccumulatedAverage<uint16_t>(a.accumulated_waiting);
2531 RotateHistory(*a.history, i->valid_history, HISTORY_YEAR, month);
2532 }
2533}
2534
2540{
2541 const IndustrySpec *indspec = GetIndustrySpec(this->type);
2542 assert(indspec->UsesOriginalEconomy());
2543
2544 /* Rates are rounded up, so e.g. oilrig always produces some passengers */
2545 for (auto &p : this->produced) {
2546 p.rate = ClampTo<uint8_t>(CeilDiv(indspec->production_rate[&p - this->produced.data()] * this->prod_level, PRODLEVEL_DEFAULT));
2547 }
2548}
2549
2550void Industry::FillCachedName() const
2551{
2552 auto tmp_params = MakeParameters(this->index);
2553 this->cached_name = GetStringWithArgs(STR_INDUSTRY_NAME, tmp_params);
2554}
2555
2556void ClearAllIndustryCachedNames()
2557{
2558 for (Industry *ind : Industry::Iterate()) {
2559 ind->cached_name.clear();
2560 }
2561}
2562
2569{
2570 uint8_t min_number;
2572 bool changed = min_number != this->min_number || probability != this->probability;
2573 this->min_number = min_number;
2574 this->probability = probability;
2575 return changed;
2576}
2577
2580{
2581 bool changed = false;
2582 uint num_planned = 0; // Number of industries planned in the industry build data.
2583 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2584 changed |= this->builddata[it].GetIndustryTypeData(it);
2585 num_planned += this->builddata[it].target_count;
2586 }
2587 uint total_amount = this->wanted_inds >> 16; // Desired total number of industries.
2588 changed |= num_planned != total_amount;
2589 if (!changed) return; // All industries are still the same, no need to re-randomize.
2590
2591 /* Initialize the target counts. */
2592 uint force_build = 0; // Number of industries that should always be available.
2593 uint32_t total_prob = 0; // Sum of probabilities.
2594 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2595 IndustryTypeBuildData *ibd = this->builddata + it;
2596 force_build += ibd->min_number;
2597 ibd->target_count = ibd->min_number;
2598 total_prob += ibd->probability;
2599 }
2600
2601 if (total_prob == 0) return; // No buildable industries.
2602
2603 /* Subtract forced industries from the number of industries available for construction. */
2604 total_amount = (total_amount <= force_build) ? 0 : total_amount - force_build;
2605
2606 /* Assign number of industries that should be aimed for, by using the probability as a weight. */
2607 while (total_amount > 0) {
2608 uint32_t r = RandomRange(total_prob);
2609 IndustryType it = 0;
2610 while (r >= this->builddata[it].probability) {
2611 r -= this->builddata[it].probability;
2612 it++;
2613 assert(it < NUM_INDUSTRYTYPES);
2614 }
2615 assert(this->builddata[it].probability > 0);
2616 this->builddata[it].target_count++;
2617 total_amount--;
2618 }
2619}
2620
2625{
2626 this->SetupTargetCount();
2627
2628 int missing = 0; // Number of industries that need to be build.
2629 uint count = 0; // Number of industry types eligible for build.
2630 uint32_t total_prob = 0; // Sum of probabilities.
2631 IndustryType forced_build = NUM_INDUSTRYTYPES; // Industry type that should be forcibly build.
2632 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2633 int difference = this->builddata[it].target_count - Industry::GetIndustryTypeCount(it);
2634 missing += difference;
2635 if (this->builddata[it].wait_count > 0) continue; // This type may not be built now.
2636 if (difference > 0) {
2637 if (Industry::GetIndustryTypeCount(it) == 0 && this->builddata[it].min_number > 0) {
2638 /* An industry that should exist at least once, is not available. Force it, trying the most needed one first. */
2639 if (forced_build == NUM_INDUSTRYTYPES ||
2640 difference > this->builddata[forced_build].target_count - Industry::GetIndustryTypeCount(forced_build)) {
2641 forced_build = it;
2642 }
2643 }
2644 total_prob += difference;
2645 count++;
2646 }
2647 }
2648
2649 if (EconomyIsInRecession() || (forced_build == NUM_INDUSTRYTYPES && (missing <= 0 || total_prob == 0))) count = 0; // Skip creation of an industry.
2650
2651 if (count >= 1) {
2652 /* If not forced, pick a weighted random industry to build.
2653 * For the case that count == 1, there is no need to draw a random number. */
2654 IndustryType it;
2655 if (forced_build != NUM_INDUSTRYTYPES) {
2656 it = forced_build;
2657 } else {
2658 /* Non-forced, select an industry type to build (weighted random). */
2659 uint32_t r = 0; // Initialized to silence the compiler.
2660 if (count > 1) r = RandomRange(total_prob);
2661 for (it = 0; it < NUM_INDUSTRYTYPES; it++) {
2662 if (this->builddata[it].wait_count > 0) continue; // Type may not be built now.
2663 int difference = this->builddata[it].target_count - Industry::GetIndustryTypeCount(it);
2664 if (difference <= 0) continue; // Too many of this kind.
2665 if (count == 1) break;
2666 if (r < (uint)difference) break;
2667 r -= difference;
2668 }
2669 assert(it < NUM_INDUSTRYTYPES && this->builddata[it].target_count > Industry::GetIndustryTypeCount(it));
2670 }
2671
2672 /* Try to create the industry. */
2673 const Industry *ind = PlaceIndustry(it, IACT_RANDOMCREATION, false);
2674 if (ind == nullptr) {
2675 this->builddata[it].wait_count = this->builddata[it].max_wait + 1; // Compensate for decrementing below.
2676 this->builddata[it].max_wait = std::min(1000, this->builddata[it].max_wait + 2);
2677 } else {
2679 this->builddata[it].max_wait = std::max(this->builddata[it].max_wait / 2, 1); // Reduce waiting time of the industry type.
2680 }
2681 }
2682
2683 /* Decrement wait counters. */
2684 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2685 if (this->builddata[it].wait_count > 0) this->builddata[it].wait_count--;
2686 }
2687}
2688
2697static bool CheckIndustryCloseDownProtection(IndustryType type)
2698{
2699 const IndustrySpec *indspec = GetIndustrySpec(type);
2700
2701 /* oil wells (or the industries with that flag set) are always allowed to closedown */
2702 if (indspec->behaviour.Test(IndustryBehaviour::DontIncrProd) && _settings_game.game_creation.landscape == LandscapeType::Temperate) return false;
2704}
2705
2715static void CanCargoServiceIndustry(CargoType cargo, Industry *ind, bool *c_accepts, bool *c_produces)
2716{
2717 if (!IsValidCargoType(cargo)) return;
2718
2719 /* Check for acceptance of cargo */
2720 if (ind->IsCargoAccepted(cargo) && !IndustryTemporarilyRefusesCargo(ind, cargo)) *c_accepts = true;
2721
2722 /* Check for produced cargo */
2723 if (ind->IsCargoProduced(cargo)) *c_produces = true;
2724}
2725
2740{
2741 if (ind->stations_near.empty()) return 0; // No stations found at all => nobody services
2742
2743 int result = 0;
2744 for (const Vehicle *v : Vehicle::Iterate()) {
2745 /* Is it worthwhile to try this vehicle? */
2746 if (v->owner != _local_company && result != 0) continue;
2747
2748 /* Check whether it accepts the right kind of cargo */
2749 bool c_accepts = false;
2750 bool c_produces = false;
2751 if (v->type == VEH_TRAIN && v->IsFrontEngine()) {
2752 for (const Vehicle *u = v; u != nullptr; u = u->Next()) {
2753 CanCargoServiceIndustry(u->cargo_type, ind, &c_accepts, &c_produces);
2754 }
2755 } else if (v->type == VEH_ROAD || v->type == VEH_SHIP || v->type == VEH_AIRCRAFT) {
2756 CanCargoServiceIndustry(v->cargo_type, ind, &c_accepts, &c_produces);
2757 } else {
2758 continue;
2759 }
2760 if (!c_accepts && !c_produces) continue; // Wrong cargo
2761
2762 /* Check orders of the vehicle.
2763 * We cannot check the first of shared orders only, since the first vehicle in such a chain
2764 * may have a different cargo type.
2765 */
2766 for (const Order &o : v->Orders()) {
2767 if (o.IsType(OT_GOTO_STATION) && !(o.GetUnloadType() & OUFB_TRANSFER)) {
2768 /* Vehicle visits a station to load or unload */
2769 Station *st = Station::Get(o.GetDestination().ToStationID());
2770 assert(st != nullptr);
2771
2772 /* Same cargo produced by industry is dropped here => not serviced by vehicle v */
2773 if ((o.GetUnloadType() & OUFB_UNLOAD) && !c_accepts) break;
2774
2775 if (ind->stations_near.find(st) != ind->stations_near.end()) {
2776 if (v->owner == _local_company) return 2; // Company services industry
2777 result = 1; // Competitor services industry
2778 }
2779 }
2780 }
2781 }
2782 return result;
2783}
2784
2792static void ReportNewsProductionChangeIndustry(Industry *ind, CargoType cargo, int percent)
2793{
2794 NewsType nt;
2795
2796 switch (WhoCanServiceIndustry(ind)) {
2797 case 0: nt = NewsType::IndustryNobody; break;
2798 case 1: nt = NewsType::IndustryOther; break;
2799 case 2: nt = NewsType::IndustryCompany; break;
2800 default: NOT_REACHED();
2801 }
2802 AddIndustryNewsItem(
2803 GetEncodedString(percent >= 0 ? STR_NEWS_INDUSTRY_PRODUCTION_INCREASE_SMOOTH : STR_NEWS_INDUSTRY_PRODUCTION_DECREASE_SMOOTH,
2804 CargoSpec::Get(cargo)->name, ind->index, abs(percent)
2805 ),
2806 nt,
2807 ind->index
2808 );
2809}
2810
2811static const uint PERCENT_TRANSPORTED_60 = 153;
2812static const uint PERCENT_TRANSPORTED_80 = 204;
2813
2819static void ChangeIndustryProduction(Industry *i, bool monthly)
2820{
2821 StringID str = STR_NULL;
2822 bool closeit = false;
2823 const IndustrySpec *indspec = GetIndustrySpec(i->type);
2824 bool standard = false;
2825 bool suppress_message = false;
2826 bool recalculate_multipliers = false;
2827 /* use original economy for industries using production related callbacks */
2828 bool original_economy = indspec->UsesOriginalEconomy();
2829 uint8_t div = 0;
2830 uint8_t mul = 0;
2831 int8_t increment = 0;
2832
2834 if (callback_enabled) {
2835 std::array<int32_t, 1> regs100;
2836 uint16_t res = GetIndustryCallback(monthly ? CBID_INDUSTRY_MONTHLYPROD_CHANGE : CBID_INDUSTRY_PRODUCTION_CHANGE, 0, Random(), i, i->type, i->location.tile, regs100);
2837 if (res != CALLBACK_FAILED) { // failed callback means "do nothing"
2838 suppress_message = HasBit(res, 7);
2839 /* Get the custom message if any */
2840 if (HasBit(res, 8)) str = MapGRFStringID(indspec->grf_prop.grfid, GRFStringID(GB(regs100[0], 0, 16)));
2841 res = GB(res, 0, 4);
2842 switch (res) {
2843 default: NOT_REACHED();
2844 case 0x0: break; // Do nothing, but show the custom message if any
2845 case 0x1: div = 1; break; // Halve industry production. If production reaches the quarter of the default, the industry is closed instead.
2846 case 0x2: mul = 1; break; // Double industry production if it hasn't reached eight times of the original yet.
2847 case 0x3: closeit = true; break; // The industry announces imminent closure, and is physically removed from the map next month.
2848 case 0x4: standard = true; break; // Do the standard random production change as if this industry was a primary one.
2849 case 0x5: case 0x6: case 0x7: // Divide production by 4, 8, 16
2850 case 0x8: div = res - 0x3; break; // Divide production by 32
2851 case 0x9: case 0xA: case 0xB: // Multiply production by 4, 8, 16
2852 case 0xC: mul = res - 0x7; break; // Multiply production by 32
2853 case 0xD: // decrement production
2854 case 0xE: // increment production
2855 increment = res == 0x0D ? -1 : 1;
2856 break;
2857 case 0xF: // Set production to third byte of register 0x100
2858 i->prod_level = Clamp(GB(regs100[0], 16, 8), PRODLEVEL_MINIMUM, PRODLEVEL_MAXIMUM);
2859 recalculate_multipliers = true;
2860 break;
2861 }
2862 }
2863 } else {
2864 if (monthly == original_economy) return;
2865 if (!original_economy && _settings_game.economy.type == ET_FROZEN) return;
2866 if (indspec->life_type == INDUSTRYLIFE_BLACK_HOLE) return;
2867 }
2868
2869 if (standard || (!callback_enabled && indspec->life_type.Any({IndustryLifeType::Organic, IndustryLifeType::Extractive}))) {
2870 /* decrease or increase */
2871 bool only_decrease = indspec->behaviour.Test(IndustryBehaviour::DontIncrProd) && _settings_game.game_creation.landscape == LandscapeType::Temperate;
2872
2873 if (original_economy) {
2874 if (only_decrease || Chance16(1, 3)) {
2875 /* If more than 60% transported, 66% chance of increase, else 33% chance of increase */
2876 if (!only_decrease && (i->GetProduced(0).history[LAST_MONTH].PctTransported() > PERCENT_TRANSPORTED_60) != Chance16(1, 3)) {
2877 mul = 1; // Increase production
2878 } else {
2879 div = 1; // Decrease production
2880 }
2881 }
2882 } else if (_settings_game.economy.type == ET_SMOOTH) {
2884 for (auto &p : i->produced) {
2885 if (!IsValidCargoType(p.cargo)) continue;
2886 uint32_t r = Random();
2887 int old_prod, new_prod, percent;
2888 /* If over 60% is transported, mult is 1, else mult is -1. */
2889 int mult = (p.history[LAST_MONTH].PctTransported() > PERCENT_TRANSPORTED_60) ? 1 : -1;
2890
2891 new_prod = old_prod = p.rate;
2892
2893 /* For industries with only_decrease flags (temperate terrain Oil Wells),
2894 * the multiplier will always be -1 so they will only decrease. */
2895 if (only_decrease) {
2896 mult = -1;
2897 /* For normal industries, if over 60% is transported, 33% chance for decrease.
2898 * Bonus for very high station ratings (over 80%): 16% chance for decrease. */
2899 } else if (Chance16I(1, ((p.history[LAST_MONTH].PctTransported() > PERCENT_TRANSPORTED_80) ? 6 : 3), r)) {
2900 mult *= -1;
2901 }
2902
2903 /* 4.5% chance for 3-23% (or 1 unit for very low productions) production change,
2904 * determined by mult value. If mult = 1 prod. increases, else (-1) it decreases. */
2905 if (Chance16I(1, 22, r >> 16)) {
2906 new_prod += mult * (std::max(((RandomRange(50) + 10) * old_prod) >> 8, 1U));
2907 }
2908
2909 /* Prevent production to overflow or Oil Rig passengers to be over-"produced" */
2910 new_prod = Clamp(new_prod, 1, 255);
2911 if (IsValidCargoType(p.cargo) && p.cargo == GetCargoTypeByLabel(CT_PASSENGERS) && !indspec->behaviour.Test(IndustryBehaviour::NoPaxProdClamp)) {
2912 new_prod = Clamp(new_prod, 0, 16);
2913 }
2914
2915 /* If override flags are set, prevent actually changing production if any was decided on */
2916 if (i->ctlflags.Test(IndustryControlFlag::NoProductionDecrease) && new_prod < old_prod) continue;
2917 if (i->ctlflags.Test(IndustryControlFlag::NoProductionIncrease) && new_prod > old_prod) continue;
2918
2919 /* Do not stop closing the industry when it has the lowest possible production rate */
2920 if (new_prod == old_prod && old_prod > 1) {
2921 closeit = false;
2922 continue;
2923 }
2924
2925 percent = (old_prod == 0) ? 100 : (new_prod * 100 / old_prod - 100);
2926 p.rate = new_prod;
2927
2928 /* Close the industry when it has the lowest possible production rate */
2929 if (new_prod > 1) closeit = false;
2930
2931 if (abs(percent) >= 10) {
2932 ReportNewsProductionChangeIndustry(i, p.cargo, percent);
2933 }
2934 }
2935 }
2936 }
2937
2938 /* If override flags are set, prevent actually changing production if any was decided on */
2939 if (i->ctlflags.Test(IndustryControlFlag::NoProductionDecrease) && (div > 0 || increment < 0)) return;
2940 if (i->ctlflags.Test(IndustryControlFlag::NoProductionIncrease) && (mul > 0 || increment > 0)) return;
2942 div = 0;
2943 mul = 0;
2944 increment = 0;
2945 }
2946
2947 if (!callback_enabled && indspec->life_type.Test(IndustryLifeType::Processing)) {
2948 if (TimerGameEconomy::year - i->last_prod_year >= PROCESSING_INDUSTRY_ABANDONMENT_YEARS && Chance16(1, original_economy ? 2 : 180)) {
2949 closeit = true;
2950 }
2951 }
2952
2953 /* Increase if needed */
2954 while (mul-- != 0 && i->prod_level < PRODLEVEL_MAXIMUM) {
2955 i->prod_level = std::min<int>(i->prod_level * 2, PRODLEVEL_MAXIMUM);
2956 recalculate_multipliers = true;
2957 if (str == STR_NULL) str = indspec->production_up_text;
2958 }
2959
2960 /* Decrease if needed */
2961 while (div-- != 0 && !closeit) {
2962 if (i->prod_level == PRODLEVEL_MINIMUM) {
2963 closeit = true;
2964 break;
2965 } else {
2966 i->prod_level = std::max<int>(i->prod_level / 2, PRODLEVEL_MINIMUM);
2967 recalculate_multipliers = true;
2968 if (str == STR_NULL) str = indspec->production_down_text;
2969 }
2970 }
2971
2972 /* Increase or Decreasing the production level if needed */
2973 if (increment != 0) {
2974 if (increment < 0 && i->prod_level == PRODLEVEL_MINIMUM) {
2975 closeit = true;
2976 } else {
2978 recalculate_multipliers = true;
2979 }
2980 }
2981
2982 /* Recalculate production_rate
2983 * For non-smooth economy these should always be synchronized with prod_level */
2984 if (recalculate_multipliers) i->RecomputeProductionMultipliers();
2985
2986 /* Close if needed and allowed */
2990 str = indspec->closure_text;
2991 }
2992
2993 if (!suppress_message && str != STR_NULL) {
2994 NewsType nt;
2995 /* Compute news category */
2996 if (closeit) {
2998 AI::BroadcastNewEvent(new ScriptEventIndustryClose(i->index));
2999 Game::NewEvent(new ScriptEventIndustryClose(i->index));
3000 } else {
3001 switch (WhoCanServiceIndustry(i)) {
3002 case 0: nt = NewsType::IndustryNobody; break;
3003 case 1: nt = NewsType::IndustryOther; break;
3004 case 2: nt = NewsType::IndustryCompany; break;
3005 default: NOT_REACHED();
3006 }
3007 }
3008 /* Set parameters of news string */
3009 EncodedString headline;
3010 if (str > STR_LAST_STRINGID) {
3011 headline = GetEncodedString(str, STR_TOWN_NAME, i->town->index, indspec->name);
3012 } else if (closeit) {
3013 headline = GetEncodedString(str, STR_FORMAT_INDUSTRY_NAME, i->town->index, indspec->name);
3014 } else {
3015 headline = GetEncodedString(str, i->index);
3016 }
3017 /* and report the news to the user */
3018 if (closeit) {
3019 AddTileNewsItem(std::move(headline), nt, i->location.tile + TileDiffXY(1, 1));
3020 } else {
3021 AddIndustryNewsItem(std::move(headline), nt, i->index);
3022 }
3023 }
3024}
3025
3033static const IntervalTimer<TimerGameEconomy> _economy_industries_daily({TimerGameEconomy::DAY, TimerGameEconomy::Priority::INDUSTRY}, [](auto)
3034{
3036
3037 /* Bits 16-31 of industry_construction_counter contain the number of industries to change/create today,
3038 * the lower 16 bit are a fractional part that might accumulate over several days until it
3039 * is sufficient for an industry. */
3040 uint16_t change_loop = _economy.industry_daily_change_counter >> 16;
3041
3042 /* Reset the active part of the counter, just keeping the "fractional part" */
3043 _economy.industry_daily_change_counter &= 0xFFFF;
3044
3045 if (change_loop == 0) {
3046 return; // Nothing to do? get out
3047 }
3048
3050
3051 /* perform the required industry changes for the day */
3052
3053 uint perc = 3; // Between 3% and 9% chance of creating a new industry.
3055 perc = std::min(9u, perc + (_industry_builder.wanted_inds >> 16) - GetCurrentTotalNumberOfIndustries());
3056 }
3057 for (uint16_t j = 0; j < change_loop; j++) {
3058 if (Chance16(perc, 100)) {
3060 } else {
3062 if (i != nullptr) {
3063 ChangeIndustryProduction(i, false);
3065 }
3066 }
3067 }
3068
3069 cur_company.Restore();
3070
3071 /* production-change */
3072 InvalidateWindowData(WC_INDUSTRY_DIRECTORY, 0, IDIWD_PRODUCTION_CHANGE);
3073});
3074
3075static const IntervalTimer<TimerGameEconomy> _economy_industries_monthly({TimerGameEconomy::MONTH, TimerGameEconomy::Priority::INDUSTRY}, [](auto)
3076{
3078
3080
3081 for (Industry *i : Industry::Iterate()) {
3083 if (i->prod_level == PRODLEVEL_CLOSURE) {
3084 delete i;
3085 } else {
3086 ChangeIndustryProduction(i, true);
3088 }
3089 }
3090
3091 cur_company.Restore();
3092
3093 /* production-change */
3094 InvalidateWindowData(WC_INDUSTRY_DIRECTORY, 0, IDIWD_PRODUCTION_CHANGE);
3095});
3096
3097
3098void InitializeIndustries()
3099{
3100 Industry::industries.fill({});
3101 _industry_sound_tile = TileIndex{};
3102
3104}
3105
3108{
3109 int count = 0;
3110 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
3111 if (Industry::GetIndustryTypeCount(it) > 0) continue; // Types of existing industries can be skipped.
3112
3113 bool force_at_least_one;
3114 uint32_t chance = GetScaledIndustryGenerationProbability(it, &force_at_least_one);
3115 if (chance == 0 || !force_at_least_one) continue; // Types that are not available can be skipped.
3116
3117 const IndustrySpec *is = GetIndustrySpec(it);
3118 ShowErrorMessage(GetEncodedString(STR_ERROR_NO_SUITABLE_PLACES_FOR_INDUSTRIES, is->name),
3119 GetEncodedString(STR_ERROR_NO_SUITABLE_PLACES_FOR_INDUSTRIES_EXPLANATION), WL_WARNING);
3120
3121 count++;
3122 if (count >= 3) break; // Don't swamp the user with errors.
3123 }
3124}
3125
3134
3140{
3141 /* Lumber mills are neither raw nor processing */
3144}
3145
3151{
3152 /* Building raw industries like secondary uses different price base */
3153 return (_price[(_settings_game.construction.raw_industry_construction == 1 && this->IsRawIndustry()) ?
3154 PR_BUILD_INDUSTRY_RAW : PR_BUILD_INDUSTRY] * this->cost_multiplier) >> 8;
3155}
3156
3164{
3165 return (_price[PR_CLEAR_INDUSTRY] * this->removal_cost_multiplier) >> 8;
3166}
3167
3182
3183static CommandCost TerraformTile_Industry(TileIndex tile, DoCommandFlags flags, int z_new, Slope tileh_new)
3184{
3185 if (AutoslopeEnabled()) {
3186 /* We imitate here TTDP's behaviour:
3187 * - Both new and old slope must not be steep.
3188 * - TileMaxZ must not be changed.
3189 * - Allow autoslope by default.
3190 * - Disallow autoslope if callback succeeds and returns non-zero.
3191 */
3192 Slope tileh_old = GetTileSlope(tile);
3193 /* TileMaxZ must not be changed. Slopes must not be steep. */
3194 if (!IsSteepSlope(tileh_old) && !IsSteepSlope(tileh_new) && (GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new))) {
3195 const IndustryGfx gfx = GetIndustryGfx(tile);
3196 const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);
3197
3198 /* Call callback 3C 'disable autosloping for industry tiles'. */
3200 /* If the callback fails, allow autoslope. */
3201 uint16_t res = GetIndustryTileCallback(CBID_INDTILE_AUTOSLOPE, 0, 0, gfx, Industry::GetByTile(tile), tile);
3202 if (res == CALLBACK_FAILED || !ConvertBooleanCallback(itspec->grf_prop.grffile, CBID_INDTILE_AUTOSLOPE, res)) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
3203 } else {
3204 /* allow autoslope */
3205 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
3206 }
3207 }
3208 }
3209 return Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
3210}
3211
3212extern const TileTypeProcs _tile_type_industry_procs = {
3213 DrawTile_Industry, // draw_tile_proc
3214 GetSlopePixelZ_Industry, // get_slope_z_proc
3215 ClearTile_Industry, // clear_tile_proc
3216 AddAcceptedCargo_Industry, // add_accepted_cargo_proc
3217 GetTileDesc_Industry, // get_tile_desc_proc
3218 GetTileTrackStatus_Industry, // get_tile_track_status_proc
3219 ClickTile_Industry, // click_tile_proc
3220 AnimateTile_Industry, // animate_tile_proc
3221 TileLoop_Industry, // tile_loop_proc
3222 ChangeTileOwner_Industry, // change_tile_owner_proc
3223 nullptr, // add_produced_cargo_proc
3224 nullptr, // vehicle_enter_tile_proc
3225 GetFoundation_Industry, // get_foundation_proc
3226 TerraformTile_Industry, // terraform_tile_proc
3227};
3228
3229bool IndustryCompare::operator() (const IndustryListEntry &lhs, const IndustryListEntry &rhs) const
3230{
3231 /* Compare by distance first and use index as a tiebreaker. */
3232 return std::tie(lhs.distance, lhs.industry->index) < std::tie(rhs.distance, rhs.industry->index);
3233}
3234
3240{
3241 auto ita = std::find_if(std::rbegin(ind->accepted), std::rend(ind->accepted), [](const auto &a) { return IsValidCargoType(a.cargo); });
3242 ind->accepted.erase(ita.base(), std::end(ind->accepted));
3243 ind->accepted.shrink_to_fit();
3244
3245 auto itp = std::find_if(std::rbegin(ind->produced), std::rend(ind->produced), [](const auto &p) { return IsValidCargoType(p.cargo); });
3246 ind->produced.erase(itp.base(), std::end(ind->produced));
3247 ind->produced.shrink_to_fit();
3248}
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.
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
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.
uint8_t CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:23
bool IsValidCargoType(CargoType cargo)
Test whether cargo type is not INVALID_CARGO.
Definition cargo_type.h:106
static constexpr CargoLabel CT_PASSENGERS
Available types of cargo Labels may be re-used between different climates.
Definition cargo_type.h:31
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:255
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr Timpl & Reset()
Reset all bits.
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.
Enum-as-bit-set wrapper.
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
An interval timer will fire every interval, and will continue to fire until it is deleted.
Definition timer.h:76
void ResetOverride()
Resets the override, which is used while initializing game.
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:59
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:228
IndustryID GetIndustryIndexOfField(Tile t)
Get the industry (farm) that made the field.
Definition clear_map.h:183
@ CLEAR_FIELDS
3
Definition clear_map.h:23
@ CLEAR_DESERT
1,3
Definition clear_map.h:25
void SetIndustryIndexOfField(Tile t, IndustryID i)
Set the industry (farm) that made the field.
Definition clear_map.h:195
void MakeField(Tile t, uint field_type, IndustryID industry)
Make a (farm) field tile.
Definition clear_map.h:268
void SetClearCounter(Tile t, uint c)
Sets the counter used to advance to the next clear density/field type.
Definition clear_map.h:132
uint GetFence(Tile t, DiagDirection side)
Is there a fence at the given border?
Definition clear_map.h:209
bool IsSnowTile(Tile t)
Test if a tile is covered with snow.
Definition clear_map.h:35
CommandCost CommandCostWithParam(StringID str, uint64_t value)
Return an error status, with string and parameter.
Definition command.cpp:417
Functions related to commands.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
@ Execute
execute the given command
@ NoModifyTownRating
do not change town rating
@ NoTestTownRating
town rating does not disallow you from building
@ NoWater
don't allow building on water
@ Auto
don't allow building on structures
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.
@ DIAGDIR_NE
Northeast, upper right on your monitor.
@ DIAGDIR_NW
Northwest.
@ DIAGDIR_SE
Southeast.
@ DIAGDIR_SW
Southwest.
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.
@ EXPENSES_CONSTRUCTION
Construction costs.
@ EXPENSES_OTHER
Other expenses.
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:17
Functions related to errors.
@ WL_WARNING
Other information.
Definition error.h:25
@ WL_INFO
Used for DoCommand-like (and some non-fatal AI GUI) errors/information.
Definition error.h:24
void ShowErrorMessage(EncodedString &&summary_msg, int x, int y, CommandCost &cc)
Display an error message in a window.
Base functions for all Games.
bool _generating_world
Whether we are generating the map or not.
Definition genworld.cpp:74
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:22
@ GWP_INDUSTRY
Generate industries.
Definition genworld.h:67
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
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.
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
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.
@ NoClosure
Industry can not close regardless of production level or time since last delivery.
@ NoProductionDecrease
When industry production change is evaluated, rolls to decrease are ignored.
@ NoProductionIncrease
When industry production change is evaluated, rolls to increase are ignored.
static uint16_t GetIndustryGamePlayProbability(IndustryType it, uint8_t *min_number)
Compute the probability for constructing a new industry during game play.
static CommandCost CheckNewIndustry_Water(TileIndex tile)
Check the conditions of CHECK_WATER (Industry should be in the desert).
static uint32_t GetScaledIndustryGenerationProbability(IndustryType it, bool *force_at_least_one)
Compute the appearance probability for an industry during map creation.
static CheckNewIndustryProc *const _check_new_industry_procs[CHECK_END]
Check functions for different types of industry.
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 uint GetCurrentTotalNumberOfIndustries()
Get total number of industries existing in the game.
static CommandCost CheckNewIndustry_OilRefinery(TileIndex tile)
Check the conditions of CHECK_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 void PlaceInitialIndustry(IndustryType type, bool try_hard)
Try to build a industry on the map.
static CommandCost CheckNewIndustry_BubbleGen(TileIndex tile)
Check the conditions of CHECK_BUBBLEGEN (Industry should be in low land).
static CommandCost CheckNewIndustry_Farm(TileIndex tile)
Check the conditions of CHECK_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 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.
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?
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.
IndustryBuildData _industry_builder
In-game manager of industries.
static Industry * PlaceIndustry(IndustryType type, IndustryAvailabilityCallType creation_type, bool try_hard)
Try to place the industry in the game.
static const IntervalTimer< TimerGameEconomy > _economy_industries_daily({TimerGameEconomy::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;} Backup< CompanyID > 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(WC_INDUSTRY_VIEW, i->index);} } } cur_company.Restore();InvalidateWindowData(WC_INDUSTRY_DIRECTORY, 0, IDIWD_PRODUCTION_CHANGE);})
Every economy day handler for the industry changes Taking the original map size of 256*256,...
static CommandCost CheckNewIndustry_Plantation(TileIndex tile)
Check the conditions of CHECK_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 CHECK_FOREST (Industry should be build above snow-line in arctic climate).
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 bool IsSuitableForFarmField(TileIndex tile, bool allow_fields)
Check whether the tile can be replaced by a farm field.
static CommandCost CheckNewIndustry_OilRig(TileIndex tile)
Check the conditions of CHECK_OIL_RIG (Industries at sea should be positioned near edge of the map).
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.
CommandCost CmdBuildIndustry(DoCommandFlags flags, TileIndex tile, IndustryType it, uint32_t first_layout, bool fund, uint32_t seed)
Build/Fund an industry.
static bool CheckIndustryCloseDownProtection(IndustryType type)
Protects an industry from closure if the appropriate flags and conditions are met CanCloseLastInstanc...
static void SetupFarmFieldFence(TileIndex tile, int size, uint8_t type, DiagDirection side)
Build farm field fence.
CommandCost CmdIndustrySetFlags(DoCommandFlags flags, IndustryID ind_id, IndustryControlFlags ctlflags)
Set industry control flags.
IndustryType GetIndustryType(Tile tile)
Retrieve the type for this industry.
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 CommandCost CheckNewIndustry_NULL(TileIndex)
Check the conditions of CHECK_NOTHING (Always succeeds).
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 CHECK_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 DrawIndustryCoordinates _coal_plant_sparks[]
Movement of the sparks , only used for Power Station.
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.
@ GFX_WATERTILE_SPECIALCHECK
not really a tile, but rather a very special check
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 const IndustryGfx INDUSTRYTILE_NOANIM
flag 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 const int INDUSTRY_ORIGINAL_NUM_INPUTS
Original number of accepted cargo types.
static const int INDUSTRY_NUM_OUTPUTS
Number of cargo types an industry can produce.
static const int INDUSTRY_NUM_INPUTS
Number of cargo types an industry can accept.
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 const IndustryGfx INVALID_INDUSTRYTILE
one above amount is considered invalid
@ CargoDistributed
Trigger when cargo is distributed.
@ IndustryTick
Trigger every tick.
@ TileLoop
Trigger in the periodic tile loop.
static const IndustryGfx NUM_INDUSTRYTILES
total number of industry tiles, new and old
static const int INDUSTRY_COMPLETED
final stage of industry construction.
@ 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.
@ CHECK_REFINERY
Industry should be positioned near edge of the map.
@ CHECK_END
End marker of the industry check procedures.
@ CHECK_OIL_RIG
Industries at sea should be positioned near edge of the map.
@ ICT_MAP_GENERATION
during random map creation
@ ICT_NORMAL_GAMEPLAY
either by user or random creation process
@ ICT_SCENARIO_EDITOR
while editing a scenario
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.).
@ Random
Randomise borders.
uint DistanceMax(TileIndex t0, TileIndex t1)
Gets the biggest distance component (x or y) between the two given tiles.
Definition map.cpp:174
uint DistanceFromEdgeDir(TileIndex tile, DiagDirection dir)
Gets the distance to the edge of the map in given direction.
Definition map.cpp:219
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:93
TileIndex TileAddXY(TileIndex tile, int x, int y)
Adds a given offset to a tile.
Definition map_func.h:469
TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
Return the offset between two tiles from a TileIndexDiffC struct.
Definition map_func.h:439
TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition map_func.h:388
TileIndexDiff TileOffsByAxis(Axis axis)
Convert an Axis to a TileIndexDiff.
Definition map_func.h:554
#define RandomTile()
Get a valid random tile.
Definition map_func.h:651
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:424
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:414
TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition map_func.h:569
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.
StringID MapGRFStringID(uint32_t grfid, GRFStringID str)
Used when setting an object's property to map to the GRF's strings while taking in consideration the ...
@ 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.
void ErrorUnknownCallbackResult(uint32_t grfid, uint16_t cbid, uint16_t cb_res)
Record that a NewGRF returned an unknown/invalid callback result.
bool ConvertBooleanCallback(const GRFFile *grffile, uint16_t cbid, uint16_t cb_res)
Converts a callback result into a boolean.
GRFConfig * GetGRFConfig(uint32_t grfid, uint32_t mask)
Retrieve a NewGRF from the current config by its grfid.
Functions/types related to NewGRF debugging.
void DeleteNewGRFInspectWindow(GrfSpecFeature feature, uint index)
Delete inspect window for a given feature and index.
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.
@ IACT_USERCREATION
from the Fund/build window
@ IACT_RANDOMCREATION
during creation of random ingame industry
@ IACT_MAPGENERATION
during random map generation
@ IACT_PROSPECTCREATION
from the Fund/build using prospecting
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.
Functions related to news.
void DeleteIndustryNews(IndustryID iid)
Remove news regarding given industry.
NewsType
Type of news.
Definition news_type.h:29
@ IndustryCompany
Production changes of industry serviced by local company.
@ IndustryClose
Closing of industries.
@ IndustryOpen
Opening of industries.
@ IndustryNobody
Other industry production changes.
@ IndustryOther
Production changes of industry serviced by competitor(s)
Base for all objects.
@ OUFB_TRANSFER
Transfer all cargo onto the platform.
Definition order_type.h:70
@ OUFB_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
@ ID_CUSTOM
Custom number of industries.
@ ID_VERY_LOW
Very few industries at game start.
@ ID_END
Number of industry density settings.
@ ID_FUND_ONLY
The game does not build 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:160
static constexpr bool IsSteepSlope(Slope s)
Checks if a slope is steep.
Definition slope_func.h:36
Foundation FlatteningFoundation(Slope s)
Returns the foundation needed to flatten a slope.
Definition slope_func.h:369
Slope ComplementSlope(Slope s)
Return the complement of a slope.
Definition slope_func.h:76
Slope
Enumeration for the slope-type.
Definition slope_type.h:48
@ SLOPE_W
the west corner of the tile is raised
Definition slope_type.h:50
@ SLOPE_E
the east corner of the tile is raised
Definition slope_type.h:52
@ SLOPE_S
the south corner of the tile is raised
Definition slope_type.h:51
@ SLOPE_N
the north corner of the tile is raised
Definition slope_type.h:53
@ SLOPE_SW
south and west corner are raised
Definition slope_type.h:56
@ SLOPE_FLAT
a flat tile
Definition slope_type.h:49
@ SLOPE_NE
north and east corner are raised
Definition slope_type.h:58
@ SLOPE_SE
south and east corner are raised
Definition slope_type.h:57
@ SLOPE_NW
north and west corner are raised
Definition slope_type.h:55
Foundation
Enumeration for Foundations.
Definition slope_type.h:93
@ FOUNDATION_LEVELED
The tile is leveled up to a flat slope.
Definition slope_type.h:95
@ FOUNDATION_NONE
The tile has no foundation, the slope remains unchanged.
Definition slope_type.h:94
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.
static PaletteID GetColourPalette(Colours colour)
Get recolour palette for a colour.
Definition sprite.h:188
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:155
PaletteID GroundSpritePaletteTransform(SpriteID image, PaletteID pal, PaletteID default_pal)
Applies PALETTE_MODIFIER_COLOUR to a palette entry of a ground sprite.
Definition sprite.h:174
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...
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:271
Functions related to low-level strings.
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:336
EncodedString GetEncodedString(StringID str)
Encode a string with no parameters into an encoded string.
Definition strings.cpp:90
Functions related to OTTD's strings.
auto MakeParameters(Args &&... args)
Helper to create the StringParameters with its own buffer with the given parameter values.
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
Class to backup a specific variable and restore it later.
const T & GetOriginalValue() const
Returns the backupped value.
void Restore()
Restore the variable.
VehicleType type
Type of vehicle.
Class for storing amounts of cargo.
Definition cargo_type.h:113
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:137
StringID name
Name of this type of cargo.
Definition cargotype.h:91
bool value
tells if the bool cheat is active or not
Definition cheat_type.h:18
Cheat magic_bulldozer
dynamite industries, objects
Definition cheat_type.h:27
SoundSettings sound
sound effect settings
uint8_t raw_industry_construction
type of (raw) industry construction (none, "normal", prospecting)
uint8_t industry_platform
the amount of flat land around an industry
uint8_t industry_density
The industry density.
This structure is the same for both Industries and Houses.
Definition sprite.h:81
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
EconomyType type
economy type (original/smooth/frozen)
bool multiple_industry_per_town
allow many industries of the same type per town
uint32_t industry_daily_change_counter
Bits 31-16 are number of industry to be performed, 15-0 are fractional collected daily.
uint32_t industry_daily_increment
The value which will increment industry_daily_change_counter. Computed value. NOSAVE.
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.
const struct GRFFile * grffile
grf file that introduced this entity
uint32_t grfid
grfid that introduced this entity.
bool HasGrfFile() const
Test if this entity was introduced by NewGRF.
uint16_t custom_industry_number
manually entered number of industries
LandscapeType landscape
the landscape we're currently in
uint8_t oil_refinery_limit
distance oil refineries allowed from map edge
uint8_t land_generator
the landscape generator
EconomySettings economy
settings to change the economy
ConstructionSettings construction
construction of things in-game
DifficultySettings difficulty
settings related to the difficulty
GameCreationSettings game_creation
settings used during the creation of a game (map)
StationSettings station
settings related to station management
Data for managing the number and type of industries in the game.
Definition industry.h:306
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:308
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:307
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.
uint8_t cost_multiplier
Base construction cost multiplier.
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.
uint8_t 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.
uint8_t anim_next
Next frame in an animation.
IndustryTileSpecialFlags special_flags
Bitmask of extra flags used by the tile.
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.
std::array< CargoType, INDUSTRY_NUM_INPUTS > accepts_cargo
Cargo accepted by this tile.
uint8_t anim_production
Animation frame to start when goods are produced.
Data for managing the number of industries of a single industry type.
Definition industry.h:291
uint32_t probability
Relative probability of building this industry.
Definition industry.h:292
uint16_t target_count
Desired number of industries of this type.
Definition industry.h:294
uint8_t min_number
Smallest number of industries that should exist (either 0 or 1).
Definition industry.h:293
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:296
uint16_t max_wait
Starting number of turns to wait (copied to wait_count).
Definition industry.h:295
CargoType cargo
Cargo type.
Definition industry.h:86
CargoType cargo
Cargo type.
Definition industry.h:74
HistoryData< ProducedHistory > history
History of cargo produced and transported for this month and 24 previous months.
Definition industry.h:77
uint8_t rate
Production rate.
Definition industry.h:76
Defines the internal data of a functional industry.
Definition industry.h:62
static Industry * GetRandom()
Return a random valid industry.
IndustryType type
type of industry.
Definition industry.h:115
Owner exclusive_supplier
Which company has exclusive rights to deliver cargo (INVALID_OWNER = anyone)
Definition industry.h:130
TimerGameCalendar::Date construction_date
Date of the construction of the industry.
Definition industry.h:127
IndustryControlFlags ctlflags
flags overriding standard behaviours
Definition industry.h:120
bool IsCargoAccepted() const
Test if this industry accepts any cargo.
Definition industry.h:223
PersistentStorage * psa
Persistent storage for NewGRF industries.
Definition industry.h:136
uint8_t prod_level
general production level
Definition industry.h:112
Colours random_colour
randomized colour of the industry, for display purpose
Definition industry.h:117
void RecomputeProductionMultipliers()
Recompute #production_rate for current prod_level.
EncodedString text
General text with additional information.
Definition industry.h:132
uint8_t construction_type
Way the industry was constructed (.
Definition industry.h:128
std::string cached_name
NOSAVE: Cache of the resolved name of the industry.
Definition industry.h:124
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:158
ValidHistoryMask valid_history
Mask of valid history records.
Definition industry.h:109
TimerGameEconomy::Year last_prod_year
last economy year of production
Definition industry.h:118
ProducedCargoes produced
produced cargo slots
Definition industry.h:110
uint16_t random
Random value used for randomisation of all kinds of things.
Definition industry.h:134
static void PostDestructor(size_t index)
Invalidating some stuff after removing item from the pool.
Town * town
Nearest town.
Definition industry.h:107
Owner founder
Founder of the industry.
Definition industry.h:126
uint8_t selected_layout
Which tile layout was used when creating the industry.
Definition industry.h:129
AcceptedCargoes accepted
accepted cargo slots
Definition industry.h:111
static uint16_t GetIndustryTypeCount(IndustryType type)
Get the count of industries for this type.
Definition industry.h:264
Owner owner
owner of the industry. Which SHOULD always be (imho) OWNER_NONE
Definition industry.h:116
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition industry.h:251
TileArea location
Location of the industry.
Definition industry.h:106
Station * neutral_station
Associated neutral station.
Definition industry.h:108
StationList stations_near
NOSAVE: List of nearby stations.
Definition industry.h:123
bool IsCargoProduced() const
Test if this industry produces any cargo.
Definition industry.h:229
Owner exclusive_consumer
Which company has exclusive rights to take cargo (INVALID_OWNER = anyone)
Definition industry.h:131
uint16_t counter
used for animation and/or production (if available cargo)
Definition industry.h:113
uint8_t was_cargo_delivered
flag that indicate this has been the closest industry chosen for cargo delivery by a station....
Definition industry.h:119
bool TileBelongsToIndustry(TileIndex tile) const
Check if a given tile belongs to this industry.
Definition industry.h:148
static std::array< FlatSet< IndustryID >, NUM_INDUSTRYTYPES > industries
List of industries of each type.
Definition industry.h:276
static TileIndex WrapToMap(TileIndex tile)
'Wraps' the given "tile" so it is within the map.
Definition map_func.h:316
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:327
static uint SizeY()
Get the size of the map along the Y.
Definition map_func.h:278
static debug_inline uint SizeX()
Get the size of the map along the X.
Definition map_func.h:269
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:340
static uint MaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition map_func.h:305
static debug_inline uint Size()
Get the size of the map.
Definition map_func.h:287
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition map_func.h:296
Represents the covered area of e.g.
void ClampToMap()
Clamp the tile area to map borders.
Definition tilearea.cpp:142
uint16_t w
The width of the area.
void Add(TileIndex to_add)
Add a single tile to a tile area; enlarge if needed.
Definition tilearea.cpp:43
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.
Definition tilearea.cpp:123
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
Templated helper to make a PoolID a single POD value.
Definition pool_type.hpp:43
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
static size_t GetPoolSize()
Returns first unused index.
static Titem * Get(auto index)
Returns Titem with given index.
static size_t GetNumItems()
Returns number of valid items in the pool.
Tindex index
Index of this pool item.
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
static bool IsValidID(auto index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static bool CleaningPool()
Returns current state of pool cleaning - yes or no.
static Titem * GetIfValid(auto index)
Returns Titem with given index.
Base class for all pools.
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
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.
bool ambient
Play ambient, industry and town sounds.
A location from where cargo can come from (or go to).
Definition source_type.h:32
static Station * Get(auto index)
Gets station with given index.
T * Next() const
Get next vehicle in the chain.
bool HasSpriteGroups() const
Check whether the entity has sprite groups.
bool serve_neutral_industries
company stations can serve industries with attached neutral stations
Station data structure.
IndustryList industries_near
Cached list of industries near the station that can accept cargo,.
Tile description for the 'land area information' tool.
Definition tile_cmd.h:36
std::optional< std::string > grf
newGRF used for the tile contents
Definition tile_cmd.h:47
StringID str
Description of the tile.
Definition tile_cmd.h:37
std::array< Owner, 4 > owner
Name of the owner(s)
Definition tile_cmd.h:39
uint64_t dparam
Parameter of the str string.
Definition tile_cmd.h:38
Tile information, used while rendering the tile.
Definition tile_cmd.h:30
Slope tileh
Slope of the tile.
Definition tile_cmd.h:31
TileIndex tile
Tile index.
Definition tile_cmd.h:32
Set of callback functions for performing tile operations of a given tile type.
Definition tile_cmd.h:142
uint32_t population
Current population of people.
Definition town.h:43
Town data structure.
Definition town.h:53
TileIndex xy
town center tile
Definition town.h:54
TownCache cache
Container for all cacheable data.
Definition town.h:56
Vehicle data structure.
CargoType cargo_type
type of cargo this vehicle is carrying
debug_inline 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:95
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
Definition tile_map.cpp:136
int GetTileZ(TileIndex tile)
Get bottom height of the tile.
Definition tile_map.cpp:116
int GetTileMaxPixelZ(TileIndex tile)
Get top height of the tile.
Definition tile_map.h:312
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition tile_map.h:96
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
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
Definition tile_map.h:279
static debug_inline uint TileHeight(Tile tile)
Returns the height of a tile.
Definition tile_map.h:29
@ TROPICZONE_RAINFOREST
Rainforest tile.
Definition tile_type.h:79
@ TROPICZONE_DESERT
Tile is desert.
Definition tile_type.h:78
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:95
static constexpr uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
@ MP_TREES
Tile got trees.
Definition tile_type.h:52
@ MP_STATION
A tile of a station.
Definition tile_type.h:53
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
Definition tile_type.h:48
@ MP_HOUSE
A house by a town.
Definition tile_type.h:51
@ MP_INDUSTRY
Part of an industry.
Definition tile_type.h:56
@ MP_VOID
Invisible tiles at the SW and SE border.
Definition tile_type.h:55
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
Definition of Interval and OneShot timers.
Definition of the game-calendar-timer.
Definition of the game-economy-timer.
Definition of the tick-based game-timer.
Base of the town class.
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...
@ TO_INDUSTRIES
industries
TransportType
Available types of transport.
Map accessors for tree tiles.
TreeGrowthStage GetTreeGrowth(Tile t)
Returns the tree growth stage.
Definition tree_map.h:195
TreeGround GetTreeGround(Tile t)
Returns the groundtype for tree tiles.
Definition tree_map.h:102
@ TREE_GROUND_SHORE
shore
Definition tree_map.h:56
@ Grown
Fully grown tree.
CommandCost EnsureNoVehicleOnGround(TileIndex tile)
Ensure there is no vehicle at the ground at the given position.
Definition vehicle.cpp:527
Functions related to vehicles.
@ VEH_ROAD
Road vehicle type.
@ VEH_AIRCRAFT
Aircraft vehicle type.
@ VEH_SHIP
Ship vehicle type.
@ VEH_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:663
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:824
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:579
Functions related to (drawing on) viewports.
Functions related to water (management)
void TileLoop_Water(TileIndex tile)
Let a water tile floods its diagonal adjoining tiles called from tunnelbridge_cmd,...
bool IsTileOnWater(Tile t)
Tests if the tile was built on water.
Definition water_map.h:136
WaterClass
classes of water (for WATER_TILE_CLEAR water tile type).
Definition water_map.h:39
@ WATER_CLASS_INVALID
Used for industry tiles on land (also for oilrig if newgrf says so).
Definition water_map.h:43
bool HasTileWaterClass(Tile t)
Checks whether the tile has an waterclass associated.
Definition water_map.h:101
WaterClass GetWaterClass(Tile t)
Get the water class at a tile.
Definition water_map.h:112
bool IsWaterTile(Tile t)
Is it a water tile with plain water?
Definition water_map.h:190
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:1184
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:3267
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition window.cpp:3149
Window functions not directly related to making/drawing windows.
@ WC_INDUSTRY_DIRECTORY
Industry directory; Window numbers:
@ WC_INDUSTRY_PRODUCTION
Industry production history graph; Window numbers:
@ WC_INDUSTRY_VIEW
Industry view; Window numbers:
@ WC_BUILD_INDUSTRY
Build industry; Window numbers: