OpenTTD Source 20250717-master-g55605ae8f2
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->x + dits->subtile_x,
378 ti->y + dits->subtile_y,
379 dits->width,
380 dits->height,
381 dits->dz,
382 ti->z,
384
385 if (IsTransparencySet(TO_INDUSTRIES)) return;
386 }
387
388 {
389 int proc = dits->draw_proc - 1;
390 if (proc >= 0) _industry_draw_tile_procs[proc](ti);
391 }
392}
393
394static int GetSlopePixelZ_Industry(TileIndex tile, uint, uint, bool)
395{
396 return GetTileMaxPixelZ(tile);
397}
398
399static Foundation GetFoundation_Industry(TileIndex tile, Slope tileh)
400{
401 IndustryGfx gfx = GetIndustryGfx(tile);
402
403 /* For NewGRF industry tiles we might not be drawing a foundation. We need to
404 * account for this, as other structures should
405 * draw the wall of the foundation in this case.
406 */
407 if (gfx >= NEW_INDUSTRYTILEOFFSET) {
408 const IndustryTileSpec *indts = GetIndustryTileSpec(gfx);
410 uint32_t callback_res = GetIndustryTileCallback(CBID_INDTILE_DRAW_FOUNDATIONS, 0, 0, gfx, Industry::GetByTile(tile), tile);
411 if (callback_res != CALLBACK_FAILED && !ConvertBooleanCallback(indts->grf_prop.grffile, CBID_INDTILE_DRAW_FOUNDATIONS, callback_res)) return FOUNDATION_NONE;
412 }
413 }
414 return FlatteningFoundation(tileh);
415}
416
417static void AddAcceptedCargo_Industry(TileIndex tile, CargoArray &acceptance, CargoTypes &always_accepted)
418{
419 IndustryGfx gfx = GetIndustryGfx(tile);
420 const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);
421 const Industry *ind = Industry::GetByTile(tile);
422
423 /* Starting point for acceptance */
424 auto accepts_cargo = itspec->accepts_cargo;
425 auto cargo_acceptance = itspec->acceptance;
426
428 /* Copy all accepted cargoes from industry itself */
429 for (const auto &a : ind->accepted) {
430 auto pos = std::ranges::find(accepts_cargo, a.cargo);
431 if (pos == std::end(accepts_cargo)) {
432 /* Not found, insert */
433 pos = std::ranges::find(accepts_cargo, INVALID_CARGO);
434 if (pos == std::end(accepts_cargo)) continue; // nowhere to place, give up on this one
435 *pos = a.cargo;
436 }
437 cargo_acceptance[std::distance(std::begin(accepts_cargo), pos)] += 8;
438 }
439 }
440
442 /* Try callback for accepts list, if success override all existing accepts */
443 uint16_t res = GetIndustryTileCallback(CBID_INDTILE_ACCEPT_CARGO, 0, 0, gfx, Industry::GetByTile(tile), tile);
444 if (res != CALLBACK_FAILED) {
445 accepts_cargo.fill(INVALID_CARGO);
446 for (uint i = 0; i < INDUSTRY_ORIGINAL_NUM_INPUTS; i++) accepts_cargo[i] = GetCargoTranslation(GB(res, i * 5, 5), itspec->grf_prop.grffile);
447 }
448 }
449
451 /* Try callback for acceptance list, if success override all existing acceptance */
452 uint16_t res = GetIndustryTileCallback(CBID_INDTILE_CARGO_ACCEPTANCE, 0, 0, gfx, Industry::GetByTile(tile), tile);
453 if (res != CALLBACK_FAILED) {
454 cargo_acceptance.fill(0);
455 for (uint i = 0; i < INDUSTRY_ORIGINAL_NUM_INPUTS; i++) cargo_acceptance[i] = GB(res, i * 4, 4);
456 }
457 }
458
459 for (uint8_t i = 0; i < std::size(itspec->accepts_cargo); i++) {
460 CargoType cargo = accepts_cargo[i];
461 if (!IsValidCargoType(cargo) || cargo_acceptance[i] <= 0) continue; // work only with valid cargoes
462
463 /* Add accepted cargo */
464 acceptance[cargo] += cargo_acceptance[i];
465
466 /* Maybe set 'always accepted' bit (if it's not set already) */
467 if (HasBit(always_accepted, cargo)) continue;
468
469 /* Test whether the industry itself accepts the cargo type */
470 if (ind->IsCargoAccepted(cargo)) continue;
471
472 /* If the industry itself doesn't accept this cargo, set 'always accepted' bit */
473 SetBit(always_accepted, cargo);
474 }
475}
476
477static void GetTileDesc_Industry(TileIndex tile, TileDesc &td)
478{
479 const Industry *i = Industry::GetByTile(tile);
480 const IndustrySpec *is = GetIndustrySpec(i->type);
481
482 td.owner[0] = i->owner;
483 td.str = is->name;
484 if (!IsIndustryCompleted(tile)) {
485 td.dparam = td.str;
486 td.str = STR_LAI_TOWN_INDUSTRY_DESCRIPTION_UNDER_CONSTRUCTION;
487 }
488
489 if (is->grf_prop.HasGrfFile()) {
491 }
492}
493
494static CommandCost ClearTile_Industry(TileIndex tile, DoCommandFlags flags)
495{
496 Industry *i = Industry::GetByTile(tile);
497 const IndustrySpec *indspec = GetIndustrySpec(i->type);
498
499 /* water can destroy industries
500 * in editor you can bulldoze industries
501 * with magic_bulldozer cheat you can destroy industries
502 * (area around OILRIG is water, so water shouldn't flood it
503 */
504 if ((_current_company != OWNER_WATER && _game_mode != GM_EDITOR &&
506 flags.Test(DoCommandFlag::Auto) ||
509 HasBit(GetIndustryTileSpec(GetIndustryGfx(tile))->slopes_refused, 5)))) {
510
511 if (flags.Test(DoCommandFlag::Auto)) {
512 return CommandCostWithParam(STR_ERROR_GENERIC_OBJECT_IN_THE_WAY, indspec->name);
513 }
515 }
516
517 if (flags.Test(DoCommandFlag::Execute)) {
518 AI::BroadcastNewEvent(new ScriptEventIndustryClose(i->index));
519 Game::NewEvent(new ScriptEventIndustryClose(i->index));
520 delete i;
521 }
523}
524
531{
532 Industry *i = Industry::GetByTile(tile);
533 const IndustrySpec *indspec = GetIndustrySpec(i->type);
534 bool moved_cargo = false;
535
536 for (auto &p : i->produced) {
537 uint cw = ClampTo<uint8_t>(p.waiting);
538 if (cw > indspec->minimal_cargo && IsValidCargoType(p.cargo)) {
539 p.waiting -= cw;
540
541 /* fluctuating economy? */
542 if (EconomyIsInRecession()) cw = (cw + 1) / 2;
543
544 p.history[THIS_MONTH].production += cw;
545
546 uint am = MoveGoodsToStation(p.cargo, cw, {i->index, SourceType::Industry}, i->stations_near, i->exclusive_consumer);
547 p.history[THIS_MONTH].transported += am;
548
549 moved_cargo |= (am != 0);
550 }
551 }
552
553 return moved_cargo;
554}
555
556static void AnimateSugarSieve(TileIndex tile)
557{
558 uint8_t m = GetAnimationFrame(tile) + 1;
559
561 switch (m & 7) {
562 case 2: SndPlayTileFx(SND_2D_SUGAR_MINE_1, tile); break;
563 case 6: SndPlayTileFx(SND_29_SUGAR_MINE_2, tile); break;
564 }
565 }
566
567 if (m >= 96) {
568 m = 0;
569 DeleteAnimatedTile(tile);
570 }
571 SetAnimationFrame(tile, m);
572
574}
575
576static void AnimateToffeeQuarry(TileIndex tile)
577{
578 uint8_t m = GetAnimationFrame(tile);
579
580 if (_industry_anim_offs_toffee[m] == 0xFF && _settings_client.sound.ambient) {
581 SndPlayTileFx(SND_30_TOFFEE_QUARRY, tile);
582 }
583
584 if (++m >= 70) {
585 m = 0;
586 DeleteAnimatedTile(tile);
587 }
588 SetAnimationFrame(tile, m);
589
591}
592
593static void AnimateBubbleCatcher(TileIndex tile)
594{
595 uint8_t m = GetAnimationFrame(tile);
596
597 if (++m >= 40) {
598 m = 0;
599 DeleteAnimatedTile(tile);
600 }
601 SetAnimationFrame(tile, m);
602
604}
605
606static void AnimatePowerPlantSparks(TileIndex tile)
607{
608 uint8_t m = GetAnimationFrame(tile);
609 if (m == 6) {
610 SetAnimationFrame(tile, 0);
611 DeleteAnimatedTile(tile);
612 } else {
613 SetAnimationFrame(tile, m + 1);
614 }
616}
617
618static void AnimateToyFactory(TileIndex tile)
619{
620 uint8_t m = GetAnimationFrame(tile) + 1;
621
622 switch (m) {
623 case 1: if (_settings_client.sound.ambient) SndPlayTileFx(SND_2C_TOY_FACTORY_1, tile); break;
624 case 23: if (_settings_client.sound.ambient) SndPlayTileFx(SND_2B_TOY_FACTORY_2, tile); break;
625 case 28: if (_settings_client.sound.ambient) SndPlayTileFx(SND_2A_TOY_FACTORY_3, tile); break;
626 default:
627 if (m >= 50) {
628 int n = GetIndustryAnimationLoop(tile) + 1;
629 m = 0;
630 if (n >= 8) {
631 n = 0;
632 DeleteAnimatedTile(tile);
633 }
635 }
636 }
637
638 SetAnimationFrame(tile, m);
640}
641
642static void AnimatePlasticFountain(TileIndex tile, IndustryGfx gfx)
643{
644 gfx = (gfx < GFX_PLASTIC_FOUNTAIN_ANIMATED_8) ? gfx + 1 : GFX_PLASTIC_FOUNTAIN_ANIMATED_1;
645 SetIndustryGfx(tile, gfx);
647}
648
649static void AnimateOilWell(TileIndex tile, IndustryGfx gfx)
650{
651 bool b = Chance16(1, 7);
652 uint8_t m = GetAnimationFrame(tile) + 1;
653 if (m == 4 && (m = 0, ++gfx) == GFX_OILWELL_ANIMATED_3 + 1 && (gfx = GFX_OILWELL_ANIMATED_1, b)) {
654 SetIndustryGfx(tile, GFX_OILWELL_NOT_ANIMATED);
656 DeleteAnimatedTile(tile);
657 } else {
658 SetAnimationFrame(tile, m);
659 SetIndustryGfx(tile, gfx);
660 }
662}
663
664static void AnimateMineTower(TileIndex tile)
665{
666 int state = TimerGameTick::counter & 0x7FF;
667
668 if ((state -= 0x400) < 0) return;
669
670 if (state < 0x1A0) {
671 if (state < 0x20 || state >= 0x180) {
672 uint8_t m = GetAnimationFrame(tile);
673 if (!(m & 0x40)) {
674 SetAnimationFrame(tile, m | 0x40);
675 if (_settings_client.sound.ambient) SndPlayTileFx(SND_0B_MINE, tile);
676 }
677 if (state & 7) return;
678 } else {
679 if (state & 3) return;
680 }
681 uint8_t m = (GetAnimationFrame(tile) + 1) | 0x40;
682 if (m > 0xC2) m = 0xC0;
683 SetAnimationFrame(tile, m);
685 } else if (state >= 0x200 && state < 0x3A0) {
686 int i = (state < 0x220 || state >= 0x380) ? 7 : 3;
687 if (state & i) return;
688
689 uint8_t m = (GetAnimationFrame(tile) & 0xBF) - 1;
690 if (m < 0x80) m = 0x82;
691 SetAnimationFrame(tile, m);
693 }
694}
695
696static void AnimateTile_Industry(TileIndex tile)
697{
698 IndustryGfx gfx = GetIndustryGfx(tile);
699
700 if (GetIndustryTileSpec(gfx)->animation.status != AnimationStatus::NoAnimation) {
701 AnimateNewIndustryTile(tile);
702 return;
703 }
704
705 switch (gfx) {
706 case GFX_SUGAR_MINE_SIEVE:
707 if ((TimerGameTick::counter & 1) == 0) AnimateSugarSieve(tile);
708 break;
709
710 case GFX_TOFFEE_QUARY:
711 if ((TimerGameTick::counter & 3) == 0) AnimateToffeeQuarry(tile);
712 break;
713
714 case GFX_BUBBLE_CATCHER:
715 if ((TimerGameTick::counter & 1) == 0) AnimateBubbleCatcher(tile);
716 break;
717
718 case GFX_POWERPLANT_SPARKS:
719 if ((TimerGameTick::counter & 3) == 0) AnimatePowerPlantSparks(tile);
720 break;
721
722 case GFX_TOY_FACTORY:
723 if ((TimerGameTick::counter & 1) == 0) AnimateToyFactory(tile);
724 break;
725
726 case GFX_PLASTIC_FOUNTAIN_ANIMATED_1: case GFX_PLASTIC_FOUNTAIN_ANIMATED_2:
727 case GFX_PLASTIC_FOUNTAIN_ANIMATED_3: case GFX_PLASTIC_FOUNTAIN_ANIMATED_4:
728 case GFX_PLASTIC_FOUNTAIN_ANIMATED_5: case GFX_PLASTIC_FOUNTAIN_ANIMATED_6:
729 case GFX_PLASTIC_FOUNTAIN_ANIMATED_7: case GFX_PLASTIC_FOUNTAIN_ANIMATED_8:
730 if ((TimerGameTick::counter & 3) == 0) AnimatePlasticFountain(tile, gfx);
731 break;
732
733 case GFX_OILWELL_ANIMATED_1:
734 case GFX_OILWELL_ANIMATED_2:
735 case GFX_OILWELL_ANIMATED_3:
736 if ((TimerGameTick::counter & 7) == 0) AnimateOilWell(tile, gfx);
737 break;
738
739 case GFX_COAL_MINE_TOWER_ANIMATED:
740 case GFX_COPPER_MINE_TOWER_ANIMATED:
741 case GFX_GOLD_MINE_TOWER_ANIMATED:
742 AnimateMineTower(tile);
743 break;
744 }
745}
746
747static void CreateChimneySmoke(TileIndex tile)
748{
749 uint x = TileX(tile) * TILE_SIZE;
750 uint y = TileY(tile) * TILE_SIZE;
751 int z = GetTileMaxPixelZ(tile);
752
753 CreateEffectVehicle(x + 15, y + 14, z + 59, EV_CHIMNEY_SMOKE);
754}
755
756static void MakeIndustryTileBigger(TileIndex tile)
757{
758 uint8_t cnt = GetIndustryConstructionCounter(tile) + 1;
759 if (cnt != 4) {
761 return;
762 }
763
764 uint8_t stage = GetIndustryConstructionStage(tile) + 1;
766 SetIndustryConstructionStage(tile, stage);
767 TriggerIndustryTileAnimation_ConstructionStageChanged(tile, false);
768 if (stage == INDUSTRY_COMPLETED) SetIndustryCompleted(tile);
769
771
772 if (!IsIndustryCompleted(tile)) return;
773
774 IndustryGfx gfx = GetIndustryGfx(tile);
775 if (gfx >= NEW_INDUSTRYTILEOFFSET) {
776 /* New industries are already animated on construction. */
777 return;
778 }
779
780 switch (gfx) {
781 case GFX_POWERPLANT_CHIMNEY:
782 CreateChimneySmoke(tile);
783 break;
784
785 case GFX_OILRIG_1: {
786 /* Do not require an industry tile to be after the first two GFX_OILRIG_1
787 * tiles (like the default oil rig). Do a proper check to ensure the
788 * tiles belong to the same industry and based on that build the oil rig's
789 * station. */
790 TileIndex other = tile + TileDiffXY(0, 1);
791
792 if (IsTileType(other, MP_INDUSTRY) &&
793 GetIndustryGfx(other) == GFX_OILRIG_1 &&
794 GetIndustryIndex(tile) == GetIndustryIndex(other)) {
795 BuildOilRig(tile);
796 }
797 break;
798 }
799
800 case GFX_TOY_FACTORY:
801 case GFX_BUBBLE_CATCHER:
802 case GFX_TOFFEE_QUARY:
803 SetAnimationFrame(tile, 0);
805 break;
806
807 case GFX_PLASTIC_FOUNTAIN_ANIMATED_1: case GFX_PLASTIC_FOUNTAIN_ANIMATED_2:
808 case GFX_PLASTIC_FOUNTAIN_ANIMATED_3: case GFX_PLASTIC_FOUNTAIN_ANIMATED_4:
809 case GFX_PLASTIC_FOUNTAIN_ANIMATED_5: case GFX_PLASTIC_FOUNTAIN_ANIMATED_6:
810 case GFX_PLASTIC_FOUNTAIN_ANIMATED_7: case GFX_PLASTIC_FOUNTAIN_ANIMATED_8:
811 AddAnimatedTile(tile, false);
812 break;
813 }
814}
815
816static void TileLoopIndustry_BubbleGenerator(TileIndex tile)
817{
818 static const int8_t _bubble_spawn_location[3][4] = {
819 { 11, 0, -4, -14 },
820 { -4, -10, -4, 1 },
821 { 49, 59, 60, 65 },
822 };
823
824 if (_settings_client.sound.ambient) SndPlayTileFx(SND_2E_BUBBLE_GENERATOR, tile);
825
826 int dir = Random() & 3;
827
829 TileX(tile) * TILE_SIZE + _bubble_spawn_location[0][dir],
830 TileY(tile) * TILE_SIZE + _bubble_spawn_location[1][dir],
831 _bubble_spawn_location[2][dir],
833 );
834
835 if (v != nullptr) v->animation_substate = dir;
836}
837
838static void TileLoop_Industry(TileIndex tile)
839{
840 if (IsTileOnWater(tile)) TileLoop_Water(tile);
841
842 /* Normally this doesn't happen, but if an industry NewGRF is removed
843 * an industry that was previously build on water can now be flooded.
844 * If this happens the tile is no longer an industry tile after
845 * returning from TileLoop_Water. */
846 if (!IsTileType(tile, MP_INDUSTRY)) return;
847
849
850 if (!IsIndustryCompleted(tile)) {
851 MakeIndustryTileBigger(tile);
852 return;
853 }
854
855 if (_game_mode == GM_EDITOR) return;
856
857 if (TransportIndustryGoods(tile) && !TriggerIndustryAnimation(Industry::GetByTile(tile), IndustryAnimationTrigger::CargoDistributed)) {
859
860 if (newgfx != INDUSTRYTILE_NOANIM) {
863 SetIndustryGfx(tile, newgfx);
865 return;
866 }
867 }
868
869 if (TriggerIndustryTileAnimation(tile, IndustryAnimationTrigger::TileLoop)) return;
870
871 IndustryGfx newgfx = GetIndustryTileSpec(GetIndustryGfx(tile))->anim_next;
872 if (newgfx != INDUSTRYTILE_NOANIM) {
874 SetIndustryGfx(tile, newgfx);
876 return;
877 }
878
879 IndustryGfx gfx = GetIndustryGfx(tile);
880 switch (gfx) {
881 case GFX_COAL_MINE_TOWER_NOT_ANIMATED:
882 case GFX_COPPER_MINE_TOWER_NOT_ANIMATED:
883 case GFX_GOLD_MINE_TOWER_NOT_ANIMATED:
884 if (!(TimerGameTick::counter & 0x400) && Chance16(1, 2)) {
885 switch (gfx) {
886 case GFX_COAL_MINE_TOWER_NOT_ANIMATED: gfx = GFX_COAL_MINE_TOWER_ANIMATED; break;
887 case GFX_COPPER_MINE_TOWER_NOT_ANIMATED: gfx = GFX_COPPER_MINE_TOWER_ANIMATED; break;
888 case GFX_GOLD_MINE_TOWER_NOT_ANIMATED: gfx = GFX_GOLD_MINE_TOWER_ANIMATED; break;
889 }
890 SetIndustryGfx(tile, gfx);
891 SetAnimationFrame(tile, 0x80);
892 AddAnimatedTile(tile);
893 }
894 break;
895
896 case GFX_OILWELL_NOT_ANIMATED:
897 if (Chance16(1, 6)) {
898 SetIndustryGfx(tile, GFX_OILWELL_ANIMATED_1);
899 SetAnimationFrame(tile, 0);
900 AddAnimatedTile(tile);
901 }
902 break;
903
904 case GFX_COAL_MINE_TOWER_ANIMATED:
905 case GFX_COPPER_MINE_TOWER_ANIMATED:
906 case GFX_GOLD_MINE_TOWER_ANIMATED:
907 if (!(TimerGameTick::counter & 0x400)) {
908 switch (gfx) {
909 case GFX_COAL_MINE_TOWER_ANIMATED: gfx = GFX_COAL_MINE_TOWER_NOT_ANIMATED; break;
910 case GFX_COPPER_MINE_TOWER_ANIMATED: gfx = GFX_COPPER_MINE_TOWER_NOT_ANIMATED; break;
911 case GFX_GOLD_MINE_TOWER_ANIMATED: gfx = GFX_GOLD_MINE_TOWER_NOT_ANIMATED; break;
912 }
913 SetIndustryGfx(tile, gfx);
916 DeleteAnimatedTile(tile);
918 }
919 break;
920
921 case GFX_POWERPLANT_SPARKS:
922 if (Chance16(1, 3)) {
923 if (_settings_client.sound.ambient) SndPlayTileFx(SND_0C_POWER_STATION, tile);
924 AddAnimatedTile(tile);
925 }
926 break;
927
928 case GFX_COPPER_MINE_CHIMNEY:
930 break;
931
932
933 case GFX_TOY_FACTORY: {
934 Industry *i = Industry::GetByTile(tile);
935 if (i->was_cargo_delivered) {
936 i->was_cargo_delivered = false;
938 AddAnimatedTile(tile);
939 }
940 }
941 break;
942
943 case GFX_BUBBLE_GENERATOR:
944 TileLoopIndustry_BubbleGenerator(tile);
945 break;
946
947 case GFX_TOFFEE_QUARY:
948 AddAnimatedTile(tile);
949 break;
950
951 case GFX_SUGAR_MINE_SIEVE:
952 if (Chance16(1, 3)) AddAnimatedTile(tile);
953 break;
954 }
955}
956
957static bool ClickTile_Industry(TileIndex tile)
958{
959 ShowIndustryViewWindow(GetIndustryIndex(tile));
960 return true;
961}
962
963static TrackStatus GetTileTrackStatus_Industry(TileIndex, TransportType, uint, DiagDirection)
964{
965 return 0;
966}
967
968static void ChangeTileOwner_Industry(TileIndex tile, Owner old_owner, Owner new_owner)
969{
970 /* If the founder merges, the industry was created by the merged company */
971 Industry *i = Industry::GetByTile(tile);
972 if (i->founder == old_owner) i->founder = (new_owner == INVALID_OWNER) ? OWNER_NONE : new_owner;
973
974 if (i->exclusive_supplier == old_owner) i->exclusive_supplier = new_owner;
975 if (i->exclusive_consumer == old_owner) i->exclusive_consumer = new_owner;
976}
977
984{
985 /* Check for industry tile */
986 if (!IsTileType(tile, MP_INDUSTRY)) return false;
987
988 const Industry *ind = Industry::GetByTile(tile);
989
990 /* Check for organic industry (i.e. not processing or extractive) */
992
993 /* Check for wood production */
994 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; });
995}
996
997static const uint8_t _plantfarmfield_type[] = {1, 1, 1, 1, 1, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6};
998
1006static bool IsSuitableForFarmField(TileIndex tile, bool allow_fields)
1007{
1008 switch (GetTileType(tile)) {
1009 case MP_CLEAR: return !IsSnowTile(tile) && !IsClearGround(tile, CLEAR_DESERT) && (allow_fields || !IsClearGround(tile, CLEAR_FIELDS));
1010 case MP_TREES: return GetTreeGround(tile) != TREE_GROUND_SHORE;
1011 default: return false;
1012 }
1013}
1014
1022static void SetupFarmFieldFence(TileIndex tile, int size, uint8_t type, DiagDirection side)
1023{
1025 TileIndexDiff neighbour_diff = TileOffsByDiagDir(side);
1026
1027 do {
1028 tile = Map::WrapToMap(tile);
1029
1030 if (IsTileType(tile, MP_CLEAR) && IsClearGround(tile, CLEAR_FIELDS)) {
1031 TileIndex neighbour = tile + neighbour_diff;
1032 if (!IsTileType(neighbour, MP_CLEAR) || !IsClearGround(neighbour, CLEAR_FIELDS) || GetFence(neighbour, ReverseDiagDir(side)) == 0) {
1033 /* Add fence as long as neighbouring tile does not already have a fence in the same position. */
1034 uint8_t or_ = type;
1035
1036 if (or_ == 1 && Chance16(1, 7)) or_ = 2;
1037
1038 SetFence(tile, side, or_);
1039 }
1040 }
1041
1042 tile += diff;
1043 } while (--size);
1044}
1045
1046static void PlantFarmField(TileIndex tile, IndustryID industry)
1047{
1048 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) {
1049 if (GetTileZ(tile) + 2 >= GetSnowLine()) return;
1050 }
1051
1052 /* determine field size */
1053 uint32_t r = (Random() & 0x303) + 0x404;
1054 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) r += 0x404;
1055 uint size_x = GB(r, 0, 8);
1056 uint size_y = GB(r, 8, 8);
1057
1058 TileArea ta(tile - TileDiffXY(std::min(TileX(tile), size_x / 2), std::min(TileY(tile), size_y / 2)), size_x, size_y);
1059 ta.ClampToMap();
1060
1061 if (ta.w == 0 || ta.h == 0) return;
1062
1063 /* check the amount of bad tiles */
1064 int count = 0;
1065 for (TileIndex cur_tile : ta) {
1066 assert(cur_tile < Map::Size());
1067 count += IsSuitableForFarmField(cur_tile, false);
1068 }
1069 if (count * 2 < ta.w * ta.h) return;
1070
1071 /* determine type of field */
1072 r = Random();
1073 uint counter = GB(r, 5, 3);
1074 uint field_type = GB(r, 8, 8) * 9 >> 8;
1075
1076 /* make field */
1077 for (TileIndex cur_tile : ta) {
1078 assert(cur_tile < Map::Size());
1079 if (IsSuitableForFarmField(cur_tile, true)) {
1080 MakeField(cur_tile, field_type, industry);
1081 SetClearCounter(cur_tile, counter);
1082 MarkTileDirtyByTile(cur_tile);
1083 }
1084 }
1085
1086 int type = 3;
1087 if (_settings_game.game_creation.landscape != LandscapeType::Arctic && _settings_game.game_creation.landscape != LandscapeType::Tropic) {
1088 type = _plantfarmfield_type[Random() & 0xF];
1089 }
1090
1091 SetupFarmFieldFence(ta.tile, ta.h, type, DIAGDIR_NE);
1092 SetupFarmFieldFence(ta.tile, ta.w, type, DIAGDIR_NW);
1093 SetupFarmFieldFence(ta.tile + TileDiffXY(ta.w - 1, 0), ta.h, type, DIAGDIR_SW);
1094 SetupFarmFieldFence(ta.tile + TileDiffXY(0, ta.h - 1), ta.w, type, DIAGDIR_SE);
1095}
1096
1097void PlantRandomFarmField(const Industry *i)
1098{
1099 int x = i->location.w / 2 + Random() % 31 - 16;
1100 int y = i->location.h / 2 + Random() % 31 - 16;
1101
1102 TileIndex tile = TileAddWrap(i->location.tile, x, y);
1103
1104 if (tile != INVALID_TILE) PlantFarmField(tile, i->index);
1105}
1106
1112{
1113 /* Don't process lumber mill if cargo is not set up correctly. */
1114 auto itp = std::begin(i->produced);
1115 if (itp == std::end(i->produced) || !IsValidCargoType(itp->cargo)) return;
1116
1117 /* We only want to cut trees if all tiles are completed. */
1118 for (TileIndex tile_cur : i->location) {
1119 if (i->TileBelongsToIndustry(tile_cur)) {
1120 if (!IsIndustryCompleted(tile_cur)) return;
1121 }
1122 }
1123
1124 for (auto tile : SpiralTileSequence(i->location.tile, 40)) { // 40x40 tiles to search.
1125 if (!IsTileType(tile, MP_TREES) || GetTreeGrowth(tile) < TreeGrowthStage::Grown) continue;
1126
1127 /* found a tree */
1128 _industry_sound_ctr = 1;
1129 _industry_sound_tile = tile;
1130 if (_settings_client.sound.ambient) SndPlayTileFx(SND_38_LUMBER_MILL_1, tile);
1131
1134
1135 /* Add according value to waiting cargo. */
1136 itp->waiting = ClampTo<uint16_t>(itp->waiting + ScaleByCargoScale(45, false));
1137 break;
1138 }
1139}
1140
1146static void ProduceIndustryGoodsHelper(Industry *i, bool scale)
1147{
1148 for (auto &p : i->produced) {
1149 if (!IsValidCargoType(p.cargo)) continue;
1150
1151 uint16_t amount = p.rate;
1152 if (scale) amount = ScaleByCargoScale(amount, false);
1153
1154 p.waiting = ClampTo<uint16_t>(p.waiting + amount);
1155 }
1156}
1157
1158static void ProduceIndustryGoods(Industry *i)
1159{
1160 const IndustrySpec *indsp = GetIndustrySpec(i->type);
1161
1162 /* play a sound? */
1163 if ((i->counter & 0x3F) == 0) {
1164 uint32_t r;
1165 if (Chance16R(1, 14, r) && !indsp->random_sounds.empty() && _settings_client.sound.ambient) {
1166 if (std::any_of(std::begin(i->produced), std::end(i->produced), [](const auto &p) { return p.history[LAST_MONTH].production > 0; })) {
1167 /* Play sound since last month had production */
1168 SndPlayTileFx(
1169 static_cast<SoundFx>(indsp->random_sounds[((r >> 16) * indsp->random_sounds.size()) >> 16]),
1170 i->location.tile);
1171 }
1172 }
1173 }
1174
1175 i->counter--;
1176
1177 /* If using an industry callback, scale the callback interval by cargo scale percentage. */
1182 }
1183 }
1184
1185 /*
1186 * All other production and special effects happen every 256 ticks, and cargo production is just scaled by the cargo scale percentage.
1187 * 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.
1188 */
1189 if ((i->counter % Ticks::INDUSTRY_PRODUCE_TICKS) == 0) {
1190 /* Handle non-callback cargo production. */
1192
1193 IndustryBehaviours indbehav = indsp->behaviour;
1194
1195 if (indbehav.Test(IndustryBehaviour::PlantFields)) {
1196 uint16_t cb_res = CALLBACK_FAILED;
1199 }
1200
1201 bool plant;
1202 if (cb_res != CALLBACK_FAILED) {
1204 } else {
1205 plant = Chance16(1, 8);
1206 }
1207
1208 if (plant) PlantRandomFarmField(i);
1209 }
1210 if (indbehav.Test(IndustryBehaviour::CutTrees)) {
1211 uint16_t cb_res = CALLBACK_FAILED;
1214 }
1215
1216 bool cut;
1217 if (cb_res != CALLBACK_FAILED) {
1219 } else {
1220 cut = ((i->counter % Ticks::INDUSTRY_CUT_TREE_TICKS) == 0);
1221 }
1222
1223 if (cut) ChopLumberMillTrees(i);
1224 }
1225
1227 TriggerIndustryAnimation(i, IndustryAnimationTrigger::IndustryTick);
1228 }
1229}
1230
1231void OnTick_Industry()
1232{
1233 if (_industry_sound_ctr != 0) {
1234 _industry_sound_ctr++;
1235
1236 if (_industry_sound_ctr == 75) {
1237 if (_settings_client.sound.ambient) SndPlayTileFx(SND_37_LUMBER_MILL_2, _industry_sound_tile);
1238 } else if (_industry_sound_ctr == 160) {
1239 _industry_sound_ctr = 0;
1240 if (_settings_client.sound.ambient) SndPlayTileFx(SND_36_LUMBER_MILL_3, _industry_sound_tile);
1241 }
1242 }
1243
1244 if (_game_mode == GM_EDITOR) return;
1245
1246 for (Industry *i : Industry::Iterate()) {
1247 ProduceIndustryGoods(i);
1248 }
1249}
1250
1256{
1257 return CommandCost();
1258}
1259
1266{
1267 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) {
1268 if (GetTileZ(tile) < HighestSnowLine() + 2) {
1269 return CommandCost(STR_ERROR_FOREST_CAN_ONLY_BE_PLANTED);
1270 }
1271 }
1272 return CommandCost();
1273}
1274
1282static bool CheckScaledDistanceFromEdge(TileIndex tile, uint maxdist)
1283{
1284 uint maxdist_x = maxdist;
1285 uint maxdist_y = maxdist;
1286
1287 if (Map::SizeX() > 256) maxdist_x *= Map::SizeX() / 256;
1288 if (Map::SizeY() > 256) maxdist_y *= Map::SizeY() / 256;
1289
1290 if (DistanceFromEdgeDir(tile, DIAGDIR_NE) < maxdist_x) return true;
1291 if (DistanceFromEdgeDir(tile, DIAGDIR_NW) < maxdist_y) return true;
1292 if (DistanceFromEdgeDir(tile, DIAGDIR_SW) < maxdist_x) return true;
1293 if (DistanceFromEdgeDir(tile, DIAGDIR_SE) < maxdist_y) return true;
1294
1295 return false;
1296}
1297
1304{
1305 if (_game_mode == GM_EDITOR) return CommandCost();
1306
1308
1309 return CommandCost(STR_ERROR_CAN_ONLY_BE_POSITIONED);
1310}
1311
1312extern bool _ignore_industry_restrictions;
1313
1320{
1321 if (_game_mode == GM_EDITOR && _ignore_industry_restrictions) return CommandCost();
1322
1323 if (TileHeight(tile) == 0 &&
1325
1326 return CommandCost(STR_ERROR_CAN_ONLY_BE_POSITIONED);
1327}
1328
1335{
1336 if (_settings_game.game_creation.landscape == LandscapeType::Arctic) {
1337 if (GetTileZ(tile) + 2 >= HighestSnowLine()) {
1338 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1339 }
1340 }
1341 return CommandCost();
1342}
1343
1350{
1351 if (GetTropicZone(tile) == TROPICZONE_DESERT) {
1352 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1353 }
1354 return CommandCost();
1355}
1356
1363{
1364 if (GetTropicZone(tile) != TROPICZONE_DESERT) {
1365 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_DESERT);
1366 }
1367 return CommandCost();
1368}
1369
1376{
1377 if (GetTropicZone(tile) != TROPICZONE_RAINFOREST) {
1378 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_RAINFOREST);
1379 }
1380 return CommandCost();
1381}
1382
1389{
1390 if (GetTileZ(tile) > 4) {
1391 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_LOW_AREAS);
1392 }
1393 return CommandCost();
1394}
1395
1402
1415
1426static CommandCost FindTownForIndustry(TileIndex tile, IndustryType type, Town **t)
1427{
1428 *t = ClosestTownFromTile(tile, UINT_MAX);
1429
1431
1432 for (const IndustryID &industry : Industry::industries[type]) {
1433 if (Industry::Get(industry)->town == *t) {
1434 *t = nullptr;
1435 return CommandCost(STR_ERROR_ONLY_ONE_ALLOWED_PER_TOWN);
1436 }
1437 }
1438
1439 return CommandCost();
1440}
1441
1442bool IsSlopeRefused(Slope current, Slope refused)
1443{
1444 if (IsSteepSlope(current)) return true;
1445 if (current != SLOPE_FLAT) {
1446 if (IsSteepSlope(refused)) return true;
1447
1448 Slope t = ComplementSlope(current);
1449
1450 if ((refused & SLOPE_W) && (t & SLOPE_NW)) return true;
1451 if ((refused & SLOPE_S) && (t & SLOPE_NE)) return true;
1452 if ((refused & SLOPE_E) && (t & SLOPE_SW)) return true;
1453 if ((refused & SLOPE_N) && (t & SLOPE_SE)) return true;
1454 }
1455
1456 return false;
1457}
1458
1466static CommandCost CheckIfIndustryTilesAreFree(TileIndex tile, const IndustryTileLayout &layout, IndustryType type)
1467{
1468 IndustryBehaviours ind_behav = GetIndustrySpec(type)->behaviour;
1469
1470 for (const IndustryTileLayoutTile &it : layout) {
1471 IndustryGfx gfx = GetTranslatedIndustryTileID(it.gfx);
1472 TileIndex cur_tile = TileAddWrap(tile, it.ti.x, it.ti.y);
1473
1474 if (!IsValidTile(cur_tile)) {
1475 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1476 }
1477
1478 if (gfx == GFX_WATERTILE_SPECIALCHECK) {
1479 if (!IsWaterTile(cur_tile) ||
1480 !IsTileFlat(cur_tile)) {
1481 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1482 }
1483 } else {
1484 CommandCost ret = EnsureNoVehicleOnGround(cur_tile);
1485 if (ret.Failed()) return ret;
1486 if (IsBridgeAbove(cur_tile)) return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1487
1488 const IndustryTileSpec *its = GetIndustryTileSpec(gfx);
1489
1490 /* Perform land/water check if not disabled */
1491 if (!HasBit(its->slopes_refused, 5) && ((HasTileWaterClass(cur_tile) && IsTileOnWater(cur_tile)) != ind_behav.Test(IndustryBehaviour::BuiltOnWater))) return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1492
1493 if (ind_behav.Any({IndustryBehaviour::OnlyInTown, IndustryBehaviour::Town1200More}) || // Tile must be a house
1494 (ind_behav.Test(IndustryBehaviour::OnlyNearTown) && IsTileType(cur_tile, MP_HOUSE))) { // Tile is allowed to be a house (and it is a house)
1495 if (!IsTileType(cur_tile, MP_HOUSE)) {
1496 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_TOWNS);
1497 }
1498
1499 /* Clear the tiles as OWNER_TOWN to not affect town rating, and to not clear protected buildings */
1501 ret = Command<CMD_LANDSCAPE_CLEAR>::Do({}, cur_tile);
1502 cur_company.Restore();
1503
1504 if (ret.Failed()) return ret;
1505 } else {
1506 /* Clear the tiles, but do not affect town ratings */
1508 if (ret.Failed()) return ret;
1509 }
1510 }
1511 }
1512
1513 return CommandCost();
1514}
1515
1528static 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)
1529{
1530 bool refused_slope = false;
1531 bool custom_shape = false;
1532
1533 for (const IndustryTileLayoutTile &it : layout) {
1534 IndustryGfx gfx = GetTranslatedIndustryTileID(it.gfx);
1535 TileIndex cur_tile = TileAddWrap(tile, it.ti.x, it.ti.y);
1536 assert(IsValidTile(cur_tile)); // checked before in CheckIfIndustryTilesAreFree
1537
1538 if (gfx != GFX_WATERTILE_SPECIALCHECK) {
1539 const IndustryTileSpec *its = GetIndustryTileSpec(gfx);
1540
1542 custom_shape = true;
1543 CommandCost ret = PerformIndustryTileSlopeCheck(tile, cur_tile, its, type, gfx, layout_index, initial_random_bits, founder, creation_type);
1544 if (ret.Failed()) return ret;
1545 } else {
1546 Slope tileh = GetTileSlope(cur_tile);
1547 refused_slope |= IsSlopeRefused(tileh, its->slopes_refused);
1548 }
1549 }
1550 }
1551
1552 if (custom_shape_check != nullptr) *custom_shape_check = custom_shape;
1553
1554 /* It is almost impossible to have a fully flat land in TG, so what we
1555 * do is that we check if we can make the land flat later on. See
1556 * CheckIfCanLevelIndustryPlatform(). */
1557 if (!refused_slope || (_settings_game.game_creation.land_generator == LG_TERRAGENESIS && _generating_world && !custom_shape && !_ignore_industry_restrictions)) {
1558 return CommandCost();
1559 }
1560 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
1561}
1562
1570static CommandCost CheckIfIndustryIsAllowed(TileIndex tile, IndustryType type, const Town *t)
1571{
1572 if (GetIndustrySpec(type)->behaviour.Test(IndustryBehaviour::Town1200More) && t->cache.population < 1200) {
1573 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_IN_TOWNS_WITH_POPULATION_OF_1200);
1574 }
1575
1576 if (GetIndustrySpec(type)->behaviour.Test(IndustryBehaviour::OnlyNearTown) && DistanceMax(t->xy, tile) > 9) {
1577 return CommandCost(STR_ERROR_CAN_ONLY_BE_BUILT_NEAR_TOWN_CENTER);
1578 }
1579
1580 return CommandCost();
1581}
1582
1583static bool CheckCanTerraformSurroundingTiles(TileIndex tile, uint height, int internal)
1584{
1585 /* Check if we don't leave the map */
1586 if (TileX(tile) == 0 || TileY(tile) == 0 || GetTileType(tile) == MP_VOID) return false;
1587
1588 TileArea ta(tile - TileDiffXY(1, 1), 2, 2);
1589 for (TileIndex tile_walk : ta) {
1590 uint curh = TileHeight(tile_walk);
1591 /* Is the tile clear? */
1592 if ((GetTileType(tile_walk) != MP_CLEAR) && (GetTileType(tile_walk) != MP_TREES)) return false;
1593
1594 /* Don't allow too big of a change if this is the sub-tile check */
1595 if (internal != 0 && Delta(curh, height) > 1) return false;
1596
1597 /* Different height, so the surrounding tiles of this tile
1598 * has to be correct too (in level, or almost in level)
1599 * else you get a chain-reaction of terraforming. */
1600 if (internal == 0 && curh != height) {
1601 if (TileX(tile_walk) == 0 || TileY(tile_walk) == 0 || !CheckCanTerraformSurroundingTiles(tile_walk + TileDiffXY(-1, -1), height, internal + 1)) {
1602 return false;
1603 }
1604 }
1605 }
1606
1607 return true;
1608}
1609
1615{
1616 int max_x = 0;
1617 int max_y = 0;
1618
1619 /* Finds dimensions of largest variant of this industry */
1620 for (const IndustryTileLayoutTile &it : layout) {
1621 if (it.gfx == GFX_WATERTILE_SPECIALCHECK) continue; // watercheck tiles don't count for footprint size
1622 if (it.ti.x > max_x) max_x = it.ti.x;
1623 if (it.ti.y > max_y) max_y = it.ti.y;
1624 }
1625
1626 /* Remember level height */
1627 uint h = TileHeight(tile);
1628
1630 /* Check that all tiles in area and surrounding are clear
1631 * this determines that there are no obstructing items */
1632
1633 /* TileArea::Expand is not used here as we need to abort
1634 * instead of clamping if the bounds cannot expanded. */
1637
1638 if (TileX(ta.tile) + ta.w >= Map::MaxX() || TileY(ta.tile) + ta.h >= Map::MaxY()) return false;
1639
1640 /* _current_company is OWNER_NONE for randomly generated industries and in editor, or the company who funded or prospected the industry.
1641 * Perform terraforming as OWNER_TOWN to disable autoslope and town ratings. */
1643
1644 for (TileIndex tile_walk : ta) {
1645 uint curh = TileHeight(tile_walk);
1646 if (curh != h) {
1647 /* This tile needs terraforming. Check if we can do that without
1648 * damaging the surroundings too much. */
1649 if (!CheckCanTerraformSurroundingTiles(tile_walk, h, 0)) {
1650 cur_company.Restore();
1651 return false;
1652 }
1653 /* This is not 100% correct check, but the best we can do without modifying the map.
1654 * What is missing, is if the difference in height is more than 1.. */
1655 if (std::get<0>(Command<CMD_TERRAFORM_LAND>::Do(DoCommandFlags{flags}.Reset(DoCommandFlag::Execute), tile_walk, SLOPE_N, curh <= h)).Failed()) {
1656 cur_company.Restore();
1657 return false;
1658 }
1659 }
1660 }
1661
1662 if (flags.Test(DoCommandFlag::Execute)) {
1663 /* Terraform the land under the industry */
1664 for (TileIndex tile_walk : ta) {
1665 uint curh = TileHeight(tile_walk);
1666 while (curh != h) {
1667 /* We give the terraforming for free here, because we can't calculate
1668 * exact cost in the test-round, and as we all know, that will cause
1669 * a nice assert if they don't match ;) */
1670 Command<CMD_TERRAFORM_LAND>::Do(flags, tile_walk, SLOPE_N, curh <= h);
1671 curh += (curh > h) ? -1 : 1;
1672 }
1673 }
1674 }
1675
1676 cur_company.Restore();
1677 return true;
1678}
1679
1680
1688{
1689 const IndustrySpec *indspec = GetIndustrySpec(type);
1690
1691 for (IndustryType conflicting_type : indspec->conflicting) {
1692 if (conflicting_type == IT_INVALID) continue;
1693
1694 for (const IndustryID &industry : Industry::industries[conflicting_type]) {
1695 /* Within 14 tiles from another industry is considered close */
1696 if (DistanceMax(tile, Industry::Get(industry)->location.tile) > 14) continue;
1697
1698 return CommandCost(STR_ERROR_INDUSTRY_TOO_CLOSE);
1699 }
1700 }
1701 return CommandCost();
1702}
1703
1708static void AdvertiseIndustryOpening(const Industry *ind)
1709{
1710 const IndustrySpec *ind_spc = GetIndustrySpec(ind->type);
1711 EncodedString headline;
1712 if (ind_spc->new_industry_text > STR_LAST_STRINGID) {
1713 headline = GetEncodedString(ind_spc->new_industry_text, ind_spc->name, STR_TOWN_NAME, ind->town->index);
1714 } else {
1715 headline = GetEncodedString(ind_spc->new_industry_text, ind_spc->name, ind->town->index);
1716 }
1717 AddIndustryNewsItem(std::move(headline), NewsType::IndustryOpen, ind->index);
1718 AI::BroadcastNewEvent(new ScriptEventIndustryOpen(ind->index));
1719 Game::NewEvent(new ScriptEventIndustryOpen(ind->index));
1720}
1721
1728{
1730 /* Industry has a neutral station. Use it and ignore any other nearby stations. */
1731 ind->stations_near.insert(ind->neutral_station);
1732 ind->neutral_station->industries_near.clear();
1734 return;
1735 }
1736
1737 ForAllStationsAroundTiles(ind->location, [ind](Station *st, TileIndex tile) {
1738 if (!IsTileType(tile, MP_INDUSTRY) || GetIndustryIndex(tile) != ind->index) return false;
1739 ind->stations_near.insert(st);
1740 st->AddIndustryToDeliver(ind, tile);
1741 return false;
1742 });
1743}
1744
1756static void DoCreateNewIndustry(Industry *i, TileIndex tile, IndustryType type, const IndustryTileLayout &layout, size_t layout_index, Town *t, Owner founder, uint16_t initial_random_bits)
1757{
1758 const IndustrySpec *indspec = GetIndustrySpec(type);
1759
1760 i->location = TileArea(tile, 1, 1);
1761 i->type = type;
1762
1763 auto &industries = Industry::industries[type];
1764 industries.insert(i->index);
1765
1766 for (size_t index = 0; index < std::size(indspec->produced_cargo); ++index) {
1767 if (!IsValidCargoType(indspec->produced_cargo[index])) break;
1768
1769 Industry::ProducedCargo &p = i->produced.emplace_back();
1770 p.cargo = indspec->produced_cargo[index];
1771 p.rate = indspec->production_rate[index];
1772 }
1773
1774 for (size_t index = 0; index < std::size(indspec->accepts_cargo); ++index) {
1775 if (!IsValidCargoType(indspec->accepts_cargo[index])) break;
1776
1777 Industry::AcceptedCargo &a = i->accepted.emplace_back();
1778 a.cargo = indspec->accepts_cargo[index];
1779 }
1780
1781 /* Randomize initial production if non-original economy is used and there are no production related callbacks. */
1782 if (!indspec->UsesOriginalEconomy()) {
1783 for (auto &p : i->produced) {
1784 p.rate = ClampTo<uint8_t>((RandomRange(256) + 128) * p.rate >> 8);
1785 }
1786 }
1787
1788 i->town = t;
1789 i->owner = OWNER_NONE;
1790
1791 uint16_t r = Random();
1792 i->random_colour = static_cast<Colours>(GB(r, 0, 4));
1793 i->counter = GB(r, 4, 12);
1794 i->random = initial_random_bits;
1795 i->was_cargo_delivered = false;
1797 i->founder = founder;
1798 i->ctlflags = {};
1799
1801 i->construction_type = (_game_mode == GM_EDITOR) ? ICT_SCENARIO_EDITOR :
1803
1804 /* Adding 1 here makes it conform to specs of var44 of varaction2 for industries
1805 * 0 = created prior of newindustries
1806 * else, chosen layout + 1 */
1807 i->selected_layout = (uint8_t)(layout_index + 1);
1808
1811
1813
1814 /* Call callbacks after the regular fields got initialised. */
1815
1818 if (res != CALLBACK_FAILED) {
1819 if (res < PRODLEVEL_MINIMUM || res > PRODLEVEL_MAXIMUM) {
1821 } else {
1822 i->prod_level = res;
1824 }
1825 }
1826 }
1827
1828 if (_generating_world) {
1831 for (auto &p : i->produced) {
1832 p.history[LAST_MONTH].production = ScaleByCargoScale(p.waiting * 8, false);
1833 p.waiting = 0;
1834 }
1835 }
1836
1837 for (auto &p : i->produced) {
1838 p.history[LAST_MONTH].production += ScaleByCargoScale(p.rate * 8, false);
1839 }
1840
1842 }
1843
1845 uint16_t res = GetIndustryCallback(CBID_INDUSTRY_DECIDE_COLOUR, 0, 0, i, type, INVALID_TILE);
1846 if (res != CALLBACK_FAILED) {
1847 if (GB(res, 4, 11) != 0) ErrorUnknownCallbackResult(indspec->grf_prop.grfid, CBID_INDUSTRY_DECIDE_COLOUR, res);
1848 i->random_colour = static_cast<Colours>(GB(res, 0, 4));
1849 }
1850 }
1851
1853 /* Clear all input cargo types */
1854 i->accepted.clear();
1855 /* Query actual types */
1857 for (uint j = 0; j < maxcargoes; j++) {
1859 if (res == CALLBACK_FAILED || GB(res, 0, 8) == UINT8_MAX) break;
1860 if (indspec->grf_prop.grffile->grf_version >= 8 && res >= 0x100) {
1862 break;
1863 }
1864 CargoType cargo = GetCargoTranslation(GB(res, 0, 8), indspec->grf_prop.grffile);
1865 /* Industries without "unlimited" cargo types support depend on the specific order/slots of cargo types.
1866 * They need to be able to blank out specific slots without aborting the callback sequence,
1867 * and solve this by returning undefined cargo indexes. Skip these. */
1869 /* As slots are allocated as needed now, this means we do need to add a slot for the invalid cargo. */
1870 Industry::AcceptedCargo &a = i->accepted.emplace_back();
1871 a.cargo = INVALID_CARGO;
1872 continue;
1873 }
1874 /* Verify valid cargo */
1875 if (std::ranges::find(indspec->accepts_cargo, cargo) == std::end(indspec->accepts_cargo)) {
1876 /* Cargo not in spec, error in NewGRF */
1878 break;
1879 }
1880 if (std::any_of(std::begin(i->accepted), std::begin(i->accepted) + j, [&cargo](const auto &a) { return a.cargo == cargo; })) {
1881 /* Duplicate cargo */
1883 break;
1884 }
1885 Industry::AcceptedCargo &a = i->accepted.emplace_back();
1886 a.cargo = cargo;
1887 }
1888 }
1889
1891 /* Clear all output cargo types */
1892 i->produced.clear();
1893 /* Query actual types */
1895 for (uint j = 0; j < maxcargoes; j++) {
1897 if (res == CALLBACK_FAILED || GB(res, 0, 8) == UINT8_MAX) break;
1898 if (indspec->grf_prop.grffile->grf_version >= 8 && res >= 0x100) {
1900 break;
1901 }
1902 CargoType cargo = GetCargoTranslation(GB(res, 0, 8), indspec->grf_prop.grffile);
1903 /* Allow older GRFs to skip slots. */
1905 /* As slots are allocated as needed now, this means we do need to add a slot for the invalid cargo. */
1906 Industry::ProducedCargo &p = i->produced.emplace_back();
1907 p.cargo = INVALID_CARGO;
1908 continue;
1909 }
1910 /* Verify valid cargo */
1911 if (std::ranges::find(indspec->produced_cargo, cargo) == std::end(indspec->produced_cargo)) {
1912 /* Cargo not in spec, error in NewGRF */
1914 break;
1915 }
1916 if (std::any_of(std::begin(i->produced), std::begin(i->produced) + j, [&cargo](const auto &p) { return p.cargo == cargo; })) {
1917 /* Duplicate cargo */
1919 break;
1920 }
1921 Industry::ProducedCargo &p = i->produced.emplace_back();
1922 p.cargo = cargo;
1923 }
1924 }
1925
1926 /* Plant the tiles */
1927
1928 for (const IndustryTileLayoutTile &it : layout) {
1929 TileIndex cur_tile = tile + ToTileIndexDiff(it.ti);
1930
1931 if (it.gfx != GFX_WATERTILE_SPECIALCHECK) {
1932 i->location.Add(cur_tile);
1933
1934 WaterClass wc = (IsWaterTile(cur_tile) ? GetWaterClass(cur_tile) : WATER_CLASS_INVALID);
1935
1937
1938 MakeIndustry(cur_tile, i->index, it.gfx, Random(), wc);
1939
1940 if (_generating_world) {
1941 SetIndustryConstructionCounter(cur_tile, 3);
1942 SetIndustryConstructionStage(cur_tile, 2);
1943 }
1944
1945 /* it->gfx is stored in the map. But the translated ID cur_gfx is the interesting one */
1946 IndustryGfx cur_gfx = GetTranslatedIndustryTileID(it.gfx);
1947 const IndustryTileSpec *its = GetIndustryTileSpec(cur_gfx);
1948 if (its->animation.status != AnimationStatus::NoAnimation) AddAnimatedTile(cur_tile);
1949 }
1950 }
1951
1952 /* Call callbacks after all tiles have been created. */
1953 for (TileIndex cur_tile : i->location) {
1954 if (i->TileBelongsToIndustry(cur_tile)) {
1955 /* There are no shared random bits, consistent with "MakeIndustryTileBigger" in tile loop.
1956 * So, trigger tiles individually */
1957 TriggerIndustryTileAnimation_ConstructionStageChanged(cur_tile, true);
1958 }
1959 }
1960
1962 for (uint j = 0; j != 50; j++) PlantRandomFarmField(i);
1963 }
1964 InvalidateWindowData(WC_INDUSTRY_DIRECTORY, 0, IDIWD_FORCE_REBUILD);
1966
1968}
1969
1986static 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)
1987{
1988 assert(layout_index < indspec->layouts.size());
1989 const IndustryTileLayout &layout = indspec->layouts[layout_index];
1990
1991 *ip = nullptr;
1992
1993 /* 1. Cheap: Built-in checks on industry level. */
1995 if (ret.Failed()) return ret;
1996
1997 Town *t = nullptr;
1998 ret = FindTownForIndustry(tile, type, &t);
1999 if (ret.Failed()) return ret;
2000 assert(t != nullptr);
2001
2002 ret = CheckIfIndustryIsAllowed(tile, type, t);
2003 if (ret.Failed()) return ret;
2004
2005 /* 2. Built-in checks on industry tiles. */
2006 std::vector<ClearedObjectArea> object_areas(_cleared_object_areas);
2007 ret = CheckIfIndustryTilesAreFree(tile, layout, type);
2008 _cleared_object_areas = std::move(object_areas);
2009 if (ret.Failed()) return ret;
2010
2011 /* 3. NewGRF-defined checks on industry level. */
2012 if (GetIndustrySpec(type)->callback_mask.Test(IndustryCallbackMask::Location)) {
2013 ret = CheckIfCallBackAllowsCreation(tile, type, layout_index, random_var8f, random_initial_bits, founder, creation_type);
2014 } else {
2015 ret = _check_new_industry_procs[indspec->check_proc](tile);
2016 }
2017 if (ret.Failed()) return ret;
2018
2019 /* 4. Expensive: NewGRF-defined checks on industry tiles. */
2020 bool custom_shape_check = false;
2021 ret = CheckIfIndustryTileSlopes(tile, layout, layout_index, type, random_initial_bits, founder, creation_type, &custom_shape_check);
2022 if (ret.Failed()) return ret;
2023
2025 !_ignore_industry_restrictions && !CheckIfCanLevelIndustryPlatform(tile, DoCommandFlag::NoWater, layout)) {
2026 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
2027 }
2028
2029 if (!Industry::CanAllocateItem()) return CommandCost(STR_ERROR_TOO_MANY_INDUSTRIES);
2030
2031 if (flags.Test(DoCommandFlag::Execute)) {
2032 *ip = new Industry(tile);
2033 if (!custom_shape_check) CheckIfCanLevelIndustryPlatform(tile, {DoCommandFlag::NoWater, DoCommandFlag::Execute}, layout);
2034 DoCreateNewIndustry(*ip, tile, type, layout, layout_index, t, founder, random_initial_bits);
2035 }
2036
2037 return CommandCost();
2038}
2039
2050CommandCost CmdBuildIndustry(DoCommandFlags flags, TileIndex tile, IndustryType it, uint32_t first_layout, bool fund, uint32_t seed)
2051{
2052 if (it >= NUM_INDUSTRYTYPES) return CMD_ERROR;
2053
2054 const IndustrySpec *indspec = GetIndustrySpec(it);
2055
2056 /* Check if the to-be built/founded industry is available for this climate. */
2057 if (!indspec->enabled || indspec->layouts.empty()) return CMD_ERROR;
2058
2059 /* If the setting for raw-material industries is not on, you cannot build raw-material industries.
2060 * Raw material industries are industries that do not accept cargo (at least for now) */
2061 if (_game_mode != GM_EDITOR && _current_company != OWNER_DEITY && _settings_game.construction.raw_industry_construction == 0 && indspec->IsRawIndustry()) {
2062 return CMD_ERROR;
2063 }
2064
2065 if (_game_mode != GM_EDITOR && GetIndustryProbabilityCallback(it, _current_company == OWNER_DEITY ? IACT_RANDOMCREATION : IACT_USERCREATION, 1) == 0) {
2066 return CMD_ERROR;
2067 }
2068
2069 Randomizer randomizer;
2070 randomizer.SetSeed(seed);
2071 uint16_t random_initial_bits = GB(seed, 0, 16);
2072 uint32_t random_var8f = randomizer.Next();
2073 size_t num_layouts = indspec->layouts.size();
2074 CommandCost ret = CommandCost(STR_ERROR_SITE_UNSUITABLE);
2075 const bool deity_prospect = _current_company == OWNER_DEITY && !fund;
2076
2077 Industry *ind = nullptr;
2078 if (deity_prospect || (_game_mode != GM_EDITOR && _current_company != OWNER_DEITY && _settings_game.construction.raw_industry_construction == 2 && indspec->IsRawIndustry())) {
2079 if (flags.Test(DoCommandFlag::Execute)) {
2080 /* Prospecting has a chance to fail, however we cannot guarantee that something can
2081 * be built on the map, so the chance gets lower when the map is fuller, but there
2082 * is nothing we can really do about that. */
2083 bool prospect_success = deity_prospect || Random() <= indspec->prospecting_chance;
2084 if (prospect_success) {
2085 /* Prospected industries are build as OWNER_TOWN to not e.g. be build on owned land of the founder */
2088 for (int i = 0; i < 5000; i++) {
2089 /* We should not have more than one Random() in a function call
2090 * because parameter evaluation order is not guaranteed in the c++ standard
2091 */
2092 tile = RandomTile();
2093 /* Start with a random layout */
2094 size_t layout = RandomRange((uint32_t)num_layouts);
2095 /* Check now each layout, starting with the random one */
2096 for (size_t j = 0; j < num_layouts; j++) {
2097 layout = (layout + 1) % num_layouts;
2098 ret = CreateNewIndustryHelper(tile, it, flags, indspec, layout, random_var8f, random_initial_bits, cur_company.GetOriginalValue(), calltype, &ind);
2099 if (ret.Succeeded()) break;
2100 }
2101 if (ret.Succeeded()) break;
2102 }
2103 cur_company.Restore();
2104 }
2105 if (ret.Failed() && IsLocalCompany()) {
2106 if (prospect_success) {
2107 ShowErrorMessage(GetEncodedString(STR_ERROR_CAN_T_PROSPECT_INDUSTRY), GetEncodedString(STR_ERROR_NO_SUITABLE_PLACES_FOR_PROSPECTING), WL_INFO);
2108 } else {
2109 ShowErrorMessage(GetEncodedString(STR_ERROR_CAN_T_PROSPECT_INDUSTRY), GetEncodedString(STR_ERROR_PROSPECTING_WAS_UNLUCKY), WL_INFO);
2110 }
2111 }
2112 }
2113 } else {
2114 size_t layout = first_layout;
2115 if (layout >= num_layouts) return CMD_ERROR;
2116
2117 /* Check subsequently each layout, starting with the given layout in p1 */
2118 for (size_t i = 0; i < num_layouts; i++) {
2119 layout = (layout + 1) % num_layouts;
2120 ret = CreateNewIndustryHelper(tile, it, flags, indspec, layout, random_var8f, random_initial_bits, _current_company, _current_company == OWNER_DEITY ? IACT_RANDOMCREATION : IACT_USERCREATION, &ind);
2121 if (ret.Succeeded()) break;
2122 }
2123
2124 /* If it still failed, there's no suitable layout to build here, return the error */
2125 if (ret.Failed()) return ret;
2126 }
2127
2128 if (flags.Test(DoCommandFlag::Execute) && ind != nullptr && _game_mode != GM_EDITOR) {
2130 }
2131
2133}
2134
2143{
2144 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2145
2146 Industry *ind = Industry::GetIfValid(ind_id);
2147 if (ind == nullptr) return CMD_ERROR;
2148 if (!ctlflags.IsValid()) return CMD_ERROR;
2149
2150 if (flags.Test(DoCommandFlag::Execute)) ind->ctlflags = ctlflags;
2151
2152 return CommandCost();
2153}
2154
2164CommandCost CmdIndustrySetProduction(DoCommandFlags flags, IndustryID ind_id, uint8_t prod_level, bool show_news, const EncodedString &custom_news)
2165{
2166 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2167 if (prod_level < PRODLEVEL_MINIMUM || prod_level > PRODLEVEL_MAXIMUM) return CMD_ERROR;
2168
2169 Industry *ind = Industry::GetIfValid(ind_id);
2170 if (ind == nullptr) return CMD_ERROR;
2171
2172 if (flags.Test(DoCommandFlag::Execute)) {
2174 ind->prod_level = prod_level;
2176
2177 /* Show news message if requested. */
2178 if (show_news && prod_level != ind->prod_level) {
2179 NewsType nt;
2180 switch (WhoCanServiceIndustry(ind)) {
2181 case 0: nt = NewsType::IndustryNobody; break;
2182 case 1: nt = NewsType::IndustryOther; break;
2183 case 2: nt = NewsType::IndustryCompany; break;
2184 default: NOT_REACHED();
2185 }
2186
2187 /* Set parameters of news string */
2188 EncodedString headline;
2189 if (!custom_news.empty()) {
2190 headline = custom_news;
2191 } else {
2192 StringID str = (prod_level > ind->prod_level)
2195
2196 if (str > STR_LAST_STRINGID) {
2197 headline = GetEncodedString(str, STR_TOWN_NAME, ind->town->index, GetIndustrySpec(ind->type)->name);
2198 } else {
2199 headline = GetEncodedString(str, ind->index);
2200 }
2201 }
2202
2203 AddIndustryNewsItem(std::move(headline), nt, ind->index);
2204 }
2205 }
2206
2207 return CommandCost();
2208}
2209
2220{
2221 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2222
2223 Industry *ind = Industry::GetIfValid(ind_id);
2224 if (ind == nullptr) return CMD_ERROR;
2225
2226 if (company_id != OWNER_NONE && company_id != INVALID_OWNER && company_id != OWNER_DEITY
2227 && !Company::IsValidID(company_id)) return CMD_ERROR;
2228
2229 if (flags.Test(DoCommandFlag::Execute)) {
2230 if (consumer) {
2231 ind->exclusive_consumer = company_id;
2232 } else {
2233 ind->exclusive_supplier = company_id;
2234 }
2235 }
2236
2237
2238 return CommandCost();
2239}
2240
2249{
2250 if (_current_company != OWNER_DEITY) return CMD_ERROR;
2251
2252 Industry *ind = Industry::GetIfValid(ind_id);
2253 if (ind == nullptr) return CMD_ERROR;
2254
2255 if (flags.Test(DoCommandFlag::Execute)) {
2256 ind->text.clear();
2257 if (!text.empty()) ind->text = text;
2259 }
2260
2261 return CommandCost();
2262}
2263
2271static Industry *CreateNewIndustry(TileIndex tile, IndustryType type, IndustryAvailabilityCallType creation_type)
2272{
2273 const IndustrySpec *indspec = GetIndustrySpec(type);
2274
2275 uint32_t seed = Random();
2276 uint32_t seed2 = Random();
2277 Industry *i = nullptr;
2278 size_t layout_index = RandomRange((uint32_t)indspec->layouts.size());
2279 [[maybe_unused]] CommandCost ret = CreateNewIndustryHelper(tile, type, DoCommandFlag::Execute, indspec, layout_index, seed, GB(seed2, 0, 16), OWNER_NONE, creation_type, &i);
2280 assert(i != nullptr || ret.Failed());
2281 return i;
2282}
2283
2290static uint32_t GetScaledIndustryGenerationProbability(IndustryType it, bool *force_at_least_one)
2291{
2292 const IndustrySpec *ind_spc = GetIndustrySpec(it);
2294 if (!ind_spc->enabled || ind_spc->layouts.empty() ||
2295 (_game_mode != GM_EDITOR && _settings_game.difficulty.industry_density == ID_FUND_ONLY) ||
2296 (chance = GetIndustryProbabilityCallback(it, IACT_MAPGENERATION, chance)) == 0) {
2297 *force_at_least_one = false;
2298 return 0;
2299 } else {
2300 chance *= 16; // to increase precision
2301 /* We want industries appearing at coast to appear less often on bigger maps, as length of coast increases slower than map area.
2302 * For simplicity we scale in both cases, though scaling the probabilities of all industries has no effect. */
2303 chance = (ind_spc->check_proc == CHECK_REFINERY || ind_spc->check_proc == CHECK_OIL_RIG) ? Map::ScaleBySize1D(chance) : Map::ScaleBySize(chance);
2304
2305 *force_at_least_one = (chance > 0) && !ind_spc->behaviour.Test(IndustryBehaviour::NoBuildMapCreation) && (_game_mode != GM_EDITOR);
2306 return chance;
2307 }
2308}
2309
2316static uint16_t GetIndustryGamePlayProbability(IndustryType it, uint8_t *min_number)
2317{
2319 *min_number = 0;
2320 return 0;
2321 }
2322
2323 const IndustrySpec *ind_spc = GetIndustrySpec(it);
2325 if (!ind_spc->enabled || ind_spc->layouts.empty() ||
2328 (chance = GetIndustryProbabilityCallback(it, IACT_RANDOMCREATION, chance)) == 0) {
2329 *min_number = 0;
2330 return 0;
2331 }
2332 *min_number = ind_spc->behaviour.Test(IndustryBehaviour::CanCloseLastInstance) ? 1 : 0;
2333 return chance;
2334}
2335
2341{
2342 /* Number of industries on a 256x256 map. */
2343 static const uint16_t numof_industry_table[] = {
2344 0, // none
2345 0, // minimal
2346 10, // very low
2347 25, // low
2348 55, // normal
2349 80, // high
2350 0, // custom
2351 };
2352
2353 assert(lengthof(numof_industry_table) == ID_END);
2354 uint difficulty = (_game_mode != GM_EDITOR) ? _settings_game.difficulty.industry_density : (uint)ID_VERY_LOW;
2355
2356 if (difficulty == ID_CUSTOM) return std::min<uint>(IndustryPool::MAX_SIZE, _settings_game.game_creation.custom_industry_number);
2357
2358 return std::min<uint>(IndustryPool::MAX_SIZE, Map::ScaleBySize(numof_industry_table[difficulty]));
2359}
2360
2369static Industry *PlaceIndustry(IndustryType type, IndustryAvailabilityCallType creation_type, bool try_hard)
2370{
2371 uint tries = try_hard ? 10000u : 2000u;
2372 for (; tries > 0; tries--) {
2373 Industry *ind = CreateNewIndustry(RandomTile(), type, creation_type);
2374 if (ind != nullptr) return ind;
2375 }
2376 return nullptr;
2377}
2378
2384static void PlaceInitialIndustry(IndustryType type, bool try_hard)
2385{
2387
2389 PlaceIndustry(type, IACT_MAPGENERATION, try_hard);
2390
2391 cur_company.Restore();
2392}
2393
2399{
2400 uint total = 0;
2401 for (const auto &industries : Industry::industries) {
2402 total += static_cast<uint16_t>(std::size(industries));
2403 }
2404 return total;
2405}
2406
2407
2410{
2411 this->probability = 0;
2412 this->min_number = 0;
2413 this->target_count = 0;
2414 this->max_wait = 1;
2415 this->wait_count = 0;
2416}
2417
2420{
2422
2423 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2424 this->builddata[it].Reset();
2425 }
2426}
2427
2430{
2431 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.
2432 if (_settings_game.difficulty.industry_density == ID_FUND_ONLY) return; // 'no industries' setting.
2433
2434 /* To prevent running out of unused industries for the player to connect,
2435 * add a fraction of new industries each month, but only if the manager can keep up. */
2436 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).
2437 if (GetCurrentTotalNumberOfIndustries() + max_behind >= (this->wanted_inds >> 16)) {
2438 this->wanted_inds += Map::ScaleBySize(NEWINDS_PER_MONTH);
2439 }
2440}
2441
2447{
2448 if (_game_mode != GM_EDITOR && _settings_game.difficulty.industry_density == ID_FUND_ONLY) return; // No industries in the game.
2449
2450 uint32_t industry_probs[NUM_INDUSTRYTYPES];
2451 bool force_at_least_one[NUM_INDUSTRYTYPES];
2452 uint32_t total_prob = 0;
2453 uint num_forced = 0;
2454
2455 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2456 industry_probs[it] = GetScaledIndustryGenerationProbability(it, force_at_least_one + it);
2457 total_prob += industry_probs[it];
2458 if (force_at_least_one[it]) num_forced++;
2459 }
2460
2461 uint total_amount = GetNumberOfIndustries();
2462 if (total_prob == 0 || total_amount < num_forced) {
2463 /* Only place the forced ones */
2464 total_amount = num_forced;
2465 }
2466
2468
2469 /* Try to build one industry per type independent of any probabilities */
2470 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2471 if (force_at_least_one[it]) {
2472 assert(total_amount > 0);
2473 total_amount--;
2474 PlaceInitialIndustry(it, true);
2475 }
2476 }
2477
2478 /* Add the remaining industries according to their probabilities */
2479 for (uint i = 0; i < total_amount; i++) {
2480 uint32_t r = RandomRange(total_prob);
2481 IndustryType it = 0;
2482 while (r >= industry_probs[it]) {
2483 r -= industry_probs[it];
2484 it++;
2485 assert(it < NUM_INDUSTRYTYPES);
2486 }
2487 assert(industry_probs[it] > 0);
2488 PlaceInitialIndustry(it, false);
2489 }
2491}
2492
2498{
2500
2501 for (auto &p : i->produced) {
2502 if (IsValidCargoType(p.cargo)) {
2503 if (p.history[THIS_MONTH].production != 0) i->last_prod_year = TimerGameEconomy::year;
2504
2505 RotateHistory(p.history);
2506 }
2507 }
2508}
2509
2515{
2516 const IndustrySpec *indspec = GetIndustrySpec(this->type);
2517 assert(indspec->UsesOriginalEconomy());
2518
2519 /* Rates are rounded up, so e.g. oilrig always produces some passengers */
2520 for (auto &p : this->produced) {
2521 p.rate = ClampTo<uint8_t>(CeilDiv(indspec->production_rate[&p - this->produced.data()] * this->prod_level, PRODLEVEL_DEFAULT));
2522 }
2523}
2524
2525void Industry::FillCachedName() const
2526{
2527 auto tmp_params = MakeParameters(this->index);
2528 this->cached_name = GetStringWithArgs(STR_INDUSTRY_NAME, tmp_params);
2529}
2530
2531void ClearAllIndustryCachedNames()
2532{
2533 for (Industry *ind : Industry::Iterate()) {
2534 ind->cached_name.clear();
2535 }
2536}
2537
2544{
2545 uint8_t min_number;
2547 bool changed = min_number != this->min_number || probability != this->probability;
2548 this->min_number = min_number;
2549 this->probability = probability;
2550 return changed;
2551}
2552
2555{
2556 bool changed = false;
2557 uint num_planned = 0; // Number of industries planned in the industry build data.
2558 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2559 changed |= this->builddata[it].GetIndustryTypeData(it);
2560 num_planned += this->builddata[it].target_count;
2561 }
2562 uint total_amount = this->wanted_inds >> 16; // Desired total number of industries.
2563 changed |= num_planned != total_amount;
2564 if (!changed) return; // All industries are still the same, no need to re-randomize.
2565
2566 /* Initialize the target counts. */
2567 uint force_build = 0; // Number of industries that should always be available.
2568 uint32_t total_prob = 0; // Sum of probabilities.
2569 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2570 IndustryTypeBuildData *ibd = this->builddata + it;
2571 force_build += ibd->min_number;
2572 ibd->target_count = ibd->min_number;
2573 total_prob += ibd->probability;
2574 }
2575
2576 if (total_prob == 0) return; // No buildable industries.
2577
2578 /* Subtract forced industries from the number of industries available for construction. */
2579 total_amount = (total_amount <= force_build) ? 0 : total_amount - force_build;
2580
2581 /* Assign number of industries that should be aimed for, by using the probability as a weight. */
2582 while (total_amount > 0) {
2583 uint32_t r = RandomRange(total_prob);
2584 IndustryType it = 0;
2585 while (r >= this->builddata[it].probability) {
2586 r -= this->builddata[it].probability;
2587 it++;
2588 assert(it < NUM_INDUSTRYTYPES);
2589 }
2590 assert(this->builddata[it].probability > 0);
2591 this->builddata[it].target_count++;
2592 total_amount--;
2593 }
2594}
2595
2600{
2601 this->SetupTargetCount();
2602
2603 int missing = 0; // Number of industries that need to be build.
2604 uint count = 0; // Number of industry types eligible for build.
2605 uint32_t total_prob = 0; // Sum of probabilities.
2606 IndustryType forced_build = NUM_INDUSTRYTYPES; // Industry type that should be forcibly build.
2607 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2608 int difference = this->builddata[it].target_count - Industry::GetIndustryTypeCount(it);
2609 missing += difference;
2610 if (this->builddata[it].wait_count > 0) continue; // This type may not be built now.
2611 if (difference > 0) {
2612 if (Industry::GetIndustryTypeCount(it) == 0 && this->builddata[it].min_number > 0) {
2613 /* An industry that should exist at least once, is not available. Force it, trying the most needed one first. */
2614 if (forced_build == NUM_INDUSTRYTYPES ||
2615 difference > this->builddata[forced_build].target_count - Industry::GetIndustryTypeCount(forced_build)) {
2616 forced_build = it;
2617 }
2618 }
2619 total_prob += difference;
2620 count++;
2621 }
2622 }
2623
2624 if (EconomyIsInRecession() || (forced_build == NUM_INDUSTRYTYPES && (missing <= 0 || total_prob == 0))) count = 0; // Skip creation of an industry.
2625
2626 if (count >= 1) {
2627 /* If not forced, pick a weighted random industry to build.
2628 * For the case that count == 1, there is no need to draw a random number. */
2629 IndustryType it;
2630 if (forced_build != NUM_INDUSTRYTYPES) {
2631 it = forced_build;
2632 } else {
2633 /* Non-forced, select an industry type to build (weighted random). */
2634 uint32_t r = 0; // Initialized to silence the compiler.
2635 if (count > 1) r = RandomRange(total_prob);
2636 for (it = 0; it < NUM_INDUSTRYTYPES; it++) {
2637 if (this->builddata[it].wait_count > 0) continue; // Type may not be built now.
2638 int difference = this->builddata[it].target_count - Industry::GetIndustryTypeCount(it);
2639 if (difference <= 0) continue; // Too many of this kind.
2640 if (count == 1) break;
2641 if (r < (uint)difference) break;
2642 r -= difference;
2643 }
2644 assert(it < NUM_INDUSTRYTYPES && this->builddata[it].target_count > Industry::GetIndustryTypeCount(it));
2645 }
2646
2647 /* Try to create the industry. */
2648 const Industry *ind = PlaceIndustry(it, IACT_RANDOMCREATION, false);
2649 if (ind == nullptr) {
2650 this->builddata[it].wait_count = this->builddata[it].max_wait + 1; // Compensate for decrementing below.
2651 this->builddata[it].max_wait = std::min(1000, this->builddata[it].max_wait + 2);
2652 } else {
2654 this->builddata[it].max_wait = std::max(this->builddata[it].max_wait / 2, 1); // Reduce waiting time of the industry type.
2655 }
2656 }
2657
2658 /* Decrement wait counters. */
2659 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
2660 if (this->builddata[it].wait_count > 0) this->builddata[it].wait_count--;
2661 }
2662}
2663
2672static bool CheckIndustryCloseDownProtection(IndustryType type)
2673{
2674 const IndustrySpec *indspec = GetIndustrySpec(type);
2675
2676 /* oil wells (or the industries with that flag set) are always allowed to closedown */
2677 if (indspec->behaviour.Test(IndustryBehaviour::DontIncrProd) && _settings_game.game_creation.landscape == LandscapeType::Temperate) return false;
2679}
2680
2690static void CanCargoServiceIndustry(CargoType cargo, Industry *ind, bool *c_accepts, bool *c_produces)
2691{
2692 if (!IsValidCargoType(cargo)) return;
2693
2694 /* Check for acceptance of cargo */
2695 if (ind->IsCargoAccepted(cargo) && !IndustryTemporarilyRefusesCargo(ind, cargo)) *c_accepts = true;
2696
2697 /* Check for produced cargo */
2698 if (ind->IsCargoProduced(cargo)) *c_produces = true;
2699}
2700
2715{
2716 if (ind->stations_near.empty()) return 0; // No stations found at all => nobody services
2717
2718 int result = 0;
2719 for (const Vehicle *v : Vehicle::Iterate()) {
2720 /* Is it worthwhile to try this vehicle? */
2721 if (v->owner != _local_company && result != 0) continue;
2722
2723 /* Check whether it accepts the right kind of cargo */
2724 bool c_accepts = false;
2725 bool c_produces = false;
2726 if (v->type == VEH_TRAIN && v->IsFrontEngine()) {
2727 for (const Vehicle *u = v; u != nullptr; u = u->Next()) {
2728 CanCargoServiceIndustry(u->cargo_type, ind, &c_accepts, &c_produces);
2729 }
2730 } else if (v->type == VEH_ROAD || v->type == VEH_SHIP || v->type == VEH_AIRCRAFT) {
2731 CanCargoServiceIndustry(v->cargo_type, ind, &c_accepts, &c_produces);
2732 } else {
2733 continue;
2734 }
2735 if (!c_accepts && !c_produces) continue; // Wrong cargo
2736
2737 /* Check orders of the vehicle.
2738 * We cannot check the first of shared orders only, since the first vehicle in such a chain
2739 * may have a different cargo type.
2740 */
2741 for (const Order &o : v->Orders()) {
2742 if (o.IsType(OT_GOTO_STATION) && !(o.GetUnloadType() & OUFB_TRANSFER)) {
2743 /* Vehicle visits a station to load or unload */
2744 Station *st = Station::Get(o.GetDestination().ToStationID());
2745 assert(st != nullptr);
2746
2747 /* Same cargo produced by industry is dropped here => not serviced by vehicle v */
2748 if ((o.GetUnloadType() & OUFB_UNLOAD) && !c_accepts) break;
2749
2750 if (ind->stations_near.find(st) != ind->stations_near.end()) {
2751 if (v->owner == _local_company) return 2; // Company services industry
2752 result = 1; // Competitor services industry
2753 }
2754 }
2755 }
2756 }
2757 return result;
2758}
2759
2767static void ReportNewsProductionChangeIndustry(Industry *ind, CargoType cargo, int percent)
2768{
2769 NewsType nt;
2770
2771 switch (WhoCanServiceIndustry(ind)) {
2772 case 0: nt = NewsType::IndustryNobody; break;
2773 case 1: nt = NewsType::IndustryOther; break;
2774 case 2: nt = NewsType::IndustryCompany; break;
2775 default: NOT_REACHED();
2776 }
2777 AddIndustryNewsItem(
2778 GetEncodedString(percent >= 0 ? STR_NEWS_INDUSTRY_PRODUCTION_INCREASE_SMOOTH : STR_NEWS_INDUSTRY_PRODUCTION_DECREASE_SMOOTH,
2779 CargoSpec::Get(cargo)->name, ind->index, abs(percent)
2780 ),
2781 nt,
2782 ind->index
2783 );
2784}
2785
2786static const uint PERCENT_TRANSPORTED_60 = 153;
2787static const uint PERCENT_TRANSPORTED_80 = 204;
2788
2794static void ChangeIndustryProduction(Industry *i, bool monthly)
2795{
2796 StringID str = STR_NULL;
2797 bool closeit = false;
2798 const IndustrySpec *indspec = GetIndustrySpec(i->type);
2799 bool standard = false;
2800 bool suppress_message = false;
2801 bool recalculate_multipliers = false;
2802 /* use original economy for industries using production related callbacks */
2803 bool original_economy = indspec->UsesOriginalEconomy();
2804 uint8_t div = 0;
2805 uint8_t mul = 0;
2806 int8_t increment = 0;
2807
2809 if (callback_enabled) {
2810 std::array<int32_t, 1> regs100;
2811 uint16_t res = GetIndustryCallback(monthly ? CBID_INDUSTRY_MONTHLYPROD_CHANGE : CBID_INDUSTRY_PRODUCTION_CHANGE, 0, Random(), i, i->type, i->location.tile, regs100);
2812 if (res != CALLBACK_FAILED) { // failed callback means "do nothing"
2813 suppress_message = HasBit(res, 7);
2814 /* Get the custom message if any */
2815 if (HasBit(res, 8)) str = MapGRFStringID(indspec->grf_prop.grfid, GRFStringID(GB(regs100[0], 0, 16)));
2816 res = GB(res, 0, 4);
2817 switch (res) {
2818 default: NOT_REACHED();
2819 case 0x0: break; // Do nothing, but show the custom message if any
2820 case 0x1: div = 1; break; // Halve industry production. If production reaches the quarter of the default, the industry is closed instead.
2821 case 0x2: mul = 1; break; // Double industry production if it hasn't reached eight times of the original yet.
2822 case 0x3: closeit = true; break; // The industry announces imminent closure, and is physically removed from the map next month.
2823 case 0x4: standard = true; break; // Do the standard random production change as if this industry was a primary one.
2824 case 0x5: case 0x6: case 0x7: // Divide production by 4, 8, 16
2825 case 0x8: div = res - 0x3; break; // Divide production by 32
2826 case 0x9: case 0xA: case 0xB: // Multiply production by 4, 8, 16
2827 case 0xC: mul = res - 0x7; break; // Multiply production by 32
2828 case 0xD: // decrement production
2829 case 0xE: // increment production
2830 increment = res == 0x0D ? -1 : 1;
2831 break;
2832 case 0xF: // Set production to third byte of register 0x100
2833 i->prod_level = Clamp(GB(regs100[0], 16, 8), PRODLEVEL_MINIMUM, PRODLEVEL_MAXIMUM);
2834 recalculate_multipliers = true;
2835 break;
2836 }
2837 }
2838 } else {
2839 if (monthly == original_economy) return;
2840 if (!original_economy && _settings_game.economy.type == ET_FROZEN) return;
2841 if (indspec->life_type == INDUSTRYLIFE_BLACK_HOLE) return;
2842 }
2843
2844 if (standard || (!callback_enabled && indspec->life_type.Any({IndustryLifeType::Organic, IndustryLifeType::Extractive}))) {
2845 /* decrease or increase */
2846 bool only_decrease = indspec->behaviour.Test(IndustryBehaviour::DontIncrProd) && _settings_game.game_creation.landscape == LandscapeType::Temperate;
2847
2848 if (original_economy) {
2849 if (only_decrease || Chance16(1, 3)) {
2850 /* If more than 60% transported, 66% chance of increase, else 33% chance of increase */
2851 if (!only_decrease && (i->GetProduced(0).history[LAST_MONTH].PctTransported() > PERCENT_TRANSPORTED_60) != Chance16(1, 3)) {
2852 mul = 1; // Increase production
2853 } else {
2854 div = 1; // Decrease production
2855 }
2856 }
2857 } else if (_settings_game.economy.type == ET_SMOOTH) {
2859 for (auto &p : i->produced) {
2860 if (!IsValidCargoType(p.cargo)) continue;
2861 uint32_t r = Random();
2862 int old_prod, new_prod, percent;
2863 /* If over 60% is transported, mult is 1, else mult is -1. */
2864 int mult = (p.history[LAST_MONTH].PctTransported() > PERCENT_TRANSPORTED_60) ? 1 : -1;
2865
2866 new_prod = old_prod = p.rate;
2867
2868 /* For industries with only_decrease flags (temperate terrain Oil Wells),
2869 * the multiplier will always be -1 so they will only decrease. */
2870 if (only_decrease) {
2871 mult = -1;
2872 /* For normal industries, if over 60% is transported, 33% chance for decrease.
2873 * Bonus for very high station ratings (over 80%): 16% chance for decrease. */
2874 } else if (Chance16I(1, ((p.history[LAST_MONTH].PctTransported() > PERCENT_TRANSPORTED_80) ? 6 : 3), r)) {
2875 mult *= -1;
2876 }
2877
2878 /* 4.5% chance for 3-23% (or 1 unit for very low productions) production change,
2879 * determined by mult value. If mult = 1 prod. increases, else (-1) it decreases. */
2880 if (Chance16I(1, 22, r >> 16)) {
2881 new_prod += mult * (std::max(((RandomRange(50) + 10) * old_prod) >> 8, 1U));
2882 }
2883
2884 /* Prevent production to overflow or Oil Rig passengers to be over-"produced" */
2885 new_prod = Clamp(new_prod, 1, 255);
2886 if (IsValidCargoType(p.cargo) && p.cargo == GetCargoTypeByLabel(CT_PASSENGERS) && !indspec->behaviour.Test(IndustryBehaviour::NoPaxProdClamp)) {
2887 new_prod = Clamp(new_prod, 0, 16);
2888 }
2889
2890 /* If override flags are set, prevent actually changing production if any was decided on */
2891 if (i->ctlflags.Test(IndustryControlFlag::NoProductionDecrease) && new_prod < old_prod) continue;
2892 if (i->ctlflags.Test(IndustryControlFlag::NoProductionIncrease) && new_prod > old_prod) continue;
2893
2894 /* Do not stop closing the industry when it has the lowest possible production rate */
2895 if (new_prod == old_prod && old_prod > 1) {
2896 closeit = false;
2897 continue;
2898 }
2899
2900 percent = (old_prod == 0) ? 100 : (new_prod * 100 / old_prod - 100);
2901 p.rate = new_prod;
2902
2903 /* Close the industry when it has the lowest possible production rate */
2904 if (new_prod > 1) closeit = false;
2905
2906 if (abs(percent) >= 10) {
2907 ReportNewsProductionChangeIndustry(i, p.cargo, percent);
2908 }
2909 }
2910 }
2911 }
2912
2913 /* If override flags are set, prevent actually changing production if any was decided on */
2914 if (i->ctlflags.Test(IndustryControlFlag::NoProductionDecrease) && (div > 0 || increment < 0)) return;
2915 if (i->ctlflags.Test(IndustryControlFlag::NoProductionIncrease) && (mul > 0 || increment > 0)) return;
2917 div = 0;
2918 mul = 0;
2919 increment = 0;
2920 }
2921
2922 if (!callback_enabled && indspec->life_type.Test(IndustryLifeType::Processing)) {
2923 if (TimerGameEconomy::year - i->last_prod_year >= PROCESSING_INDUSTRY_ABANDONMENT_YEARS && Chance16(1, original_economy ? 2 : 180)) {
2924 closeit = true;
2925 }
2926 }
2927
2928 /* Increase if needed */
2929 while (mul-- != 0 && i->prod_level < PRODLEVEL_MAXIMUM) {
2930 i->prod_level = std::min<int>(i->prod_level * 2, PRODLEVEL_MAXIMUM);
2931 recalculate_multipliers = true;
2932 if (str == STR_NULL) str = indspec->production_up_text;
2933 }
2934
2935 /* Decrease if needed */
2936 while (div-- != 0 && !closeit) {
2937 if (i->prod_level == PRODLEVEL_MINIMUM) {
2938 closeit = true;
2939 break;
2940 } else {
2941 i->prod_level = std::max<int>(i->prod_level / 2, PRODLEVEL_MINIMUM);
2942 recalculate_multipliers = true;
2943 if (str == STR_NULL) str = indspec->production_down_text;
2944 }
2945 }
2946
2947 /* Increase or Decreasing the production level if needed */
2948 if (increment != 0) {
2949 if (increment < 0 && i->prod_level == PRODLEVEL_MINIMUM) {
2950 closeit = true;
2951 } else {
2953 recalculate_multipliers = true;
2954 }
2955 }
2956
2957 /* Recalculate production_rate
2958 * For non-smooth economy these should always be synchronized with prod_level */
2959 if (recalculate_multipliers) i->RecomputeProductionMultipliers();
2960
2961 /* Close if needed and allowed */
2965 str = indspec->closure_text;
2966 }
2967
2968 if (!suppress_message && str != STR_NULL) {
2969 NewsType nt;
2970 /* Compute news category */
2971 if (closeit) {
2973 AI::BroadcastNewEvent(new ScriptEventIndustryClose(i->index));
2974 Game::NewEvent(new ScriptEventIndustryClose(i->index));
2975 } else {
2976 switch (WhoCanServiceIndustry(i)) {
2977 case 0: nt = NewsType::IndustryNobody; break;
2978 case 1: nt = NewsType::IndustryOther; break;
2979 case 2: nt = NewsType::IndustryCompany; break;
2980 default: NOT_REACHED();
2981 }
2982 }
2983 /* Set parameters of news string */
2984 EncodedString headline;
2985 if (str > STR_LAST_STRINGID) {
2986 headline = GetEncodedString(str, STR_TOWN_NAME, i->town->index, indspec->name);
2987 } else if (closeit) {
2988 headline = GetEncodedString(str, STR_FORMAT_INDUSTRY_NAME, i->town->index, indspec->name);
2989 } else {
2990 headline = GetEncodedString(str, i->index);
2991 }
2992 /* and report the news to the user */
2993 if (closeit) {
2994 AddTileNewsItem(std::move(headline), nt, i->location.tile + TileDiffXY(1, 1));
2995 } else {
2996 AddIndustryNewsItem(std::move(headline), nt, i->index);
2997 }
2998 }
2999}
3000
3008static const IntervalTimer<TimerGameEconomy> _economy_industries_daily({TimerGameEconomy::DAY, TimerGameEconomy::Priority::INDUSTRY}, [](auto)
3009{
3011
3012 /* Bits 16-31 of industry_construction_counter contain the number of industries to change/create today,
3013 * the lower 16 bit are a fractional part that might accumulate over several days until it
3014 * is sufficient for an industry. */
3015 uint16_t change_loop = _economy.industry_daily_change_counter >> 16;
3016
3017 /* Reset the active part of the counter, just keeping the "fractional part" */
3018 _economy.industry_daily_change_counter &= 0xFFFF;
3019
3020 if (change_loop == 0) {
3021 return; // Nothing to do? get out
3022 }
3023
3025
3026 /* perform the required industry changes for the day */
3027
3028 uint perc = 3; // Between 3% and 9% chance of creating a new industry.
3030 perc = std::min(9u, perc + (_industry_builder.wanted_inds >> 16) - GetCurrentTotalNumberOfIndustries());
3031 }
3032 for (uint16_t j = 0; j < change_loop; j++) {
3033 if (Chance16(perc, 100)) {
3035 } else {
3037 if (i != nullptr) {
3038 ChangeIndustryProduction(i, false);
3040 }
3041 }
3042 }
3043
3044 cur_company.Restore();
3045
3046 /* production-change */
3047 InvalidateWindowData(WC_INDUSTRY_DIRECTORY, 0, IDIWD_PRODUCTION_CHANGE);
3048});
3049
3050static const IntervalTimer<TimerGameEconomy> _economy_industries_monthly({TimerGameEconomy::MONTH, TimerGameEconomy::Priority::INDUSTRY}, [](auto)
3051{
3053
3055
3056 for (Industry *i : Industry::Iterate()) {
3058 if (i->prod_level == PRODLEVEL_CLOSURE) {
3059 delete i;
3060 } else {
3061 ChangeIndustryProduction(i, true);
3063 }
3064 }
3065
3066 cur_company.Restore();
3067
3068 /* production-change */
3069 InvalidateWindowData(WC_INDUSTRY_DIRECTORY, 0, IDIWD_PRODUCTION_CHANGE);
3070});
3071
3072
3073void InitializeIndustries()
3074{
3075 Industry::industries.fill({});
3076 _industry_sound_tile = TileIndex{};
3077
3079}
3080
3083{
3084 int count = 0;
3085 for (IndustryType it = 0; it < NUM_INDUSTRYTYPES; it++) {
3086 if (Industry::GetIndustryTypeCount(it) > 0) continue; // Types of existing industries can be skipped.
3087
3088 bool force_at_least_one;
3089 uint32_t chance = GetScaledIndustryGenerationProbability(it, &force_at_least_one);
3090 if (chance == 0 || !force_at_least_one) continue; // Types that are not available can be skipped.
3091
3092 const IndustrySpec *is = GetIndustrySpec(it);
3093 ShowErrorMessage(GetEncodedString(STR_ERROR_NO_SUITABLE_PLACES_FOR_INDUSTRIES, is->name),
3094 GetEncodedString(STR_ERROR_NO_SUITABLE_PLACES_FOR_INDUSTRIES_EXPLANATION), WL_WARNING);
3095
3096 count++;
3097 if (count >= 3) break; // Don't swamp the user with errors.
3098 }
3099}
3100
3109
3115{
3116 /* Lumber mills are neither raw nor processing */
3119}
3120
3126{
3127 /* Building raw industries like secondary uses different price base */
3128 return (_price[(_settings_game.construction.raw_industry_construction == 1 && this->IsRawIndustry()) ?
3129 PR_BUILD_INDUSTRY_RAW : PR_BUILD_INDUSTRY] * this->cost_multiplier) >> 8;
3130}
3131
3139{
3140 return (_price[PR_CLEAR_INDUSTRY] * this->removal_cost_multiplier) >> 8;
3141}
3142
3157
3158static CommandCost TerraformTile_Industry(TileIndex tile, DoCommandFlags flags, int z_new, Slope tileh_new)
3159{
3160 if (AutoslopeEnabled()) {
3161 /* We imitate here TTDP's behaviour:
3162 * - Both new and old slope must not be steep.
3163 * - TileMaxZ must not be changed.
3164 * - Allow autoslope by default.
3165 * - Disallow autoslope if callback succeeds and returns non-zero.
3166 */
3167 Slope tileh_old = GetTileSlope(tile);
3168 /* TileMaxZ must not be changed. Slopes must not be steep. */
3169 if (!IsSteepSlope(tileh_old) && !IsSteepSlope(tileh_new) && (GetTileMaxZ(tile) == z_new + GetSlopeMaxZ(tileh_new))) {
3170 const IndustryGfx gfx = GetIndustryGfx(tile);
3171 const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);
3172
3173 /* Call callback 3C 'disable autosloping for industry tiles'. */
3175 /* If the callback fails, allow autoslope. */
3176 uint16_t res = GetIndustryTileCallback(CBID_INDTILE_AUTOSLOPE, 0, 0, gfx, Industry::GetByTile(tile), tile);
3177 if (res == CALLBACK_FAILED || !ConvertBooleanCallback(itspec->grf_prop.grffile, CBID_INDTILE_AUTOSLOPE, res)) return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
3178 } else {
3179 /* allow autoslope */
3180 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
3181 }
3182 }
3183 }
3184 return Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
3185}
3186
3187extern const TileTypeProcs _tile_type_industry_procs = {
3188 DrawTile_Industry, // draw_tile_proc
3189 GetSlopePixelZ_Industry, // get_slope_z_proc
3190 ClearTile_Industry, // clear_tile_proc
3191 AddAcceptedCargo_Industry, // add_accepted_cargo_proc
3192 GetTileDesc_Industry, // get_tile_desc_proc
3193 GetTileTrackStatus_Industry, // get_tile_track_status_proc
3194 ClickTile_Industry, // click_tile_proc
3195 AnimateTile_Industry, // animate_tile_proc
3196 TileLoop_Industry, // tile_loop_proc
3197 ChangeTileOwner_Industry, // change_tile_owner_proc
3198 nullptr, // add_produced_cargo_proc
3199 nullptr, // vehicle_enter_tile_proc
3200 GetFoundation_Industry, // get_foundation_proc
3201 TerraformTile_Industry, // terraform_tile_proc
3202};
3203
3204bool IndustryCompare::operator() (const IndustryListEntry &lhs, const IndustryListEntry &rhs) const
3205{
3206 /* Compare by distance first and use index as a tiebreaker. */
3207 return std::tie(lhs.distance, lhs.industry->index) < std::tie(rhs.distance, rhs.industry->index);
3208}
3209
3215{
3216 auto ita = std::find_if(std::rbegin(ind->accepted), std::rend(ind->accepted), [](const auto &a) { return IsValidCargoType(a.cargo); });
3217 ind->accepted.erase(ita.base(), std::end(ind->accepted));
3218 ind->accepted.shrink_to_fit();
3219
3220 auto itp = std::find_if(std::rbegin(ind->produced), std::rend(ind->produced), [](const auto &p) { return IsValidCargoType(p.cargo); });
3221 ind->produced.erase(itp.base(), std::end(ind->produced));
3222 ind->produced.shrink_to_fit();
3223}
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 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 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.
Functions for storing historical data.
void UpdateValidHistory(ValidHistoryMask &valid_history)
Update mask of valid history records.
void RotateHistory(HistoryData< T > &history)
Rotate history.
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:184
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:151
PaletteID GroundSpritePaletteTransform(SpriteID image, PaletteID pal, PaletteID default_pal)
Applies PALETTE_MODIFIER_COLOUR to a palette entry of a ground sprite.
Definition sprite.h:170
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:337
EncodedString GetEncodedString(StringID str)
Encode a string with no parameters into an encoded string.
Definition strings.cpp:91
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:72
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:289
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:291
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:290
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:274
uint32_t probability
Relative probability of building this industry.
Definition industry.h:275
uint16_t target_count
Desired number of industries of this type.
Definition industry.h:277
uint8_t min_number
Smallest number of industries that should exist (either 0 or 1).
Definition industry.h:276
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:279
uint16_t max_wait
Starting number of turns to wait (copied to wait_count).
Definition industry.h:278
CargoType cargo
Cargo type.
Definition industry.h:81
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:98
Owner exclusive_supplier
Which company has exclusive rights to deliver cargo (INVALID_OWNER = anyone)
Definition industry.h:113
TimerGameCalendar::Date construction_date
Date of the construction of the industry.
Definition industry.h:110
IndustryControlFlags ctlflags
flags overriding standard behaviours
Definition industry.h:103
bool IsCargoAccepted() const
Test if this industry accepts any cargo.
Definition industry.h:206
PersistentStorage * psa
Persistent storage for NewGRF industries.
Definition industry.h:119
uint8_t prod_level
general production level
Definition industry.h:95
Colours random_colour
randomized colour of the industry, for display purpose
Definition industry.h:100
void RecomputeProductionMultipliers()
Recompute #production_rate for current prod_level.
EncodedString text
General text with additional information.
Definition industry.h:115
uint8_t construction_type
Way the industry was constructed (.
Definition industry.h:111
std::string cached_name
NOSAVE: Cache of the resolved name of the industry.
Definition industry.h:107
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:141
ValidHistoryMask valid_history
Mask of valid history records.
Definition industry.h:92
TimerGameEconomy::Year last_prod_year
last economy year of production
Definition industry.h:101
ProducedCargoes produced
produced cargo slots
Definition industry.h:93
uint16_t random
Random value used for randomisation of all kinds of things.
Definition industry.h:117
static void PostDestructor(size_t index)
Invalidating some stuff after removing item from the pool.
Town * town
Nearest town.
Definition industry.h:90
Owner founder
Founder of the industry.
Definition industry.h:109
uint8_t selected_layout
Which tile layout was used when creating the industry.
Definition industry.h:112
AcceptedCargoes accepted
accepted cargo slots
Definition industry.h:94
static uint16_t GetIndustryTypeCount(IndustryType type)
Get the count of industries for this type.
Definition industry.h:247
Owner owner
owner of the industry. Which SHOULD always be (imho) OWNER_NONE
Definition industry.h:99
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition industry.h:234
TileArea location
Location of the industry.
Definition industry.h:89
Station * neutral_station
Associated neutral station.
Definition industry.h:91
StationList stations_near
NOSAVE: List of nearby stations.
Definition industry.h:106
bool IsCargoProduced() const
Test if this industry produces any cargo.
Definition industry.h:212
Owner exclusive_consumer
Which company has exclusive rights to take cargo (INVALID_OWNER = anyone)
Definition industry.h:114
uint16_t counter
used for animation and/or production (if available cargo)
Definition industry.h:96
uint8_t was_cargo_delivered
flag that indicate this has been the closest industry chosen for cargo delivery by a station....
Definition industry.h:102
bool TileBelongsToIndustry(TileIndex tile) const
Check if a given tile belongs to this industry.
Definition industry.h:131
static std::array< FlatSet< IndustryID >, NUM_INDUSTRYTYPES > industries
List of industries of each type.
Definition industry.h:259
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:38
std::optional< std::string > grf
newGRF used for the tile contents
Definition tile_cmd.h:49
StringID str
Description of the tile.
Definition tile_cmd.h:39
std::array< Owner, 4 > owner
Name of the owner(s)
Definition tile_cmd.h:41
uint64_t dparam
Parameter of the str string.
Definition tile_cmd.h:40
Tile information, used while rendering the tile.
Definition tile_cmd.h:29
int z
Height.
Definition tile_cmd.h:34
int x
X position of the tile in unit coordinates.
Definition tile_cmd.h:30
Slope tileh
Slope of the tile.
Definition tile_cmd.h:32
TileIndex tile
Tile index.
Definition tile_cmd.h:33
int y
Y position of the tile in unit coordinates.
Definition tile_cmd.h:31
Set of callback functions for performing tile operations of a given tile type.
Definition tile_cmd.h:144
uint32_t population
Current population of people.
Definition town.h:42
Town data structure.
Definition town.h:52
TileIndex xy
town center tile
Definition town.h:53
TownCache cache
Container for all cacheable data.
Definition town.h:55
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
static const uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
@ 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
@ 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 w, int h, int dz, int z, bool transparent, int bb_offset_x, int bb_offset_y, int bb_offset_z, const SubSprite *sub)
Draw a (transparent) sprite at given coordinates with a given bounding box.
Definition viewport.cpp: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:819
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:1182
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:3265
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition window.cpp:3147
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: