OpenTTD Source: src/subsidy.cpp Source File

OpenTTD Source 1.11.0-RC1

subsidy.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 "company_func.h"
12 #include "industry.h"
13 #include "town.h"
14 #include "news_func.h"
15 #include "ai/ai.hpp"
16 #include "station_base.h"
17 #include "strings_func.h"
18 #include "window_func.h"
19 #include "subsidy_base.h"
20 #include "subsidy_func.h"
21 #include "core/pool_func.hpp"
22 #include "core/random_func.hpp"
23 #include "game/game.hpp"
24 #include "command_func.h"
25 #include "string_func.h"
26 #include "tile_cmd.h"
27
28 #include "table/strings.h"
29
30 #include "safeguards.h"
31
32 SubsidyPool _subsidy_pool("Subsidy");
33 INSTANTIATE_POOL_METHODS(Subsidy)
34
35
39 void Subsidy::AwardTo(CompanyID company)
40 {
41 assert(!this->IsAwarded());
42
43 this->awarded = company;
44 this->remaining = SUBSIDY_CONTRACT_MONTHS;
45
46 char company_name[MAX_LENGTH_COMPANY_NAME_CHARS * MAX_CHAR_LENGTH];
47 SetDParam(0, company);
48 GetString(company_name, STR_COMPANY_NAME, lastof(company_name));
49
50 char *cn = stredup(company_name);
51
52 /* Add a news item */
53 Pair reftype = SetupSubsidyDecodeParam(this, false);
54 InjectDParam(1);
55
56 SetDParamStr(0, cn);
57 AddNewsItem(
58 STR_NEWS_SERVICE_SUBSIDY_AWARDED_HALF + _settings_game.difficulty.subsidy_multiplier,
59 NT_SUBSIDIES, NF_NORMAL,
60 (NewsReferenceType)reftype.a, this->src, (NewsReferenceType)reftype.b, this->dst,
61 cn
62 );
63 AI::BroadcastNewEvent(new ScriptEventSubsidyAwarded(this->index));
64 Game::NewEvent(new ScriptEventSubsidyAwarded(this->index));
65
66 InvalidateWindowData(WC_SUBSIDIES_LIST, 0);
67 }
68
75 Pair SetupSubsidyDecodeParam(const Subsidy *s, bool mode)
76 {
77 NewsReferenceType reftype1 = NR_NONE;
78 NewsReferenceType reftype2 = NR_NONE;
79
80 /* if mode is false, use the singular form */
81 const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
82 SetDParam(0, mode ? cs->name : cs->name_single);
83
84 switch (s->src_type) {
85 case ST_INDUSTRY:
86 reftype1 = NR_INDUSTRY;
87 SetDParam(1, STR_INDUSTRY_NAME);
88 break;
89 case ST_TOWN:
90 reftype1 = NR_TOWN;
91 SetDParam(1, STR_TOWN_NAME);
92 break;
93 default: NOT_REACHED();
94 }
95 SetDParam(2, s->src);
96
97 switch (s->dst_type) {
98 case ST_INDUSTRY:
99 reftype2 = NR_INDUSTRY;
100 SetDParam(4, STR_INDUSTRY_NAME);
101 break;
102 case ST_TOWN:
103 reftype2 = NR_TOWN;
104 SetDParam(4, STR_TOWN_NAME);
105 break;
106 default: NOT_REACHED();
107 }
108 SetDParam(5, s->dst);
109
110 Pair p;
111 p.a = reftype1;
112 p.b = reftype2;
113 return p;
114 }
115
122 static inline void SetPartOfSubsidyFlag(SourceType type, SourceID index, PartOfSubsidy flag)
123 {
124 switch (type) {
125 case ST_INDUSTRY: Industry::Get(index)->part_of_subsidy |= flag; return;
126 case ST_TOWN: Town::Get(index)->cache.part_of_subsidy |= flag; return;
127 default: NOT_REACHED();
128 }
129 }
130
132 void RebuildSubsidisedSourceAndDestinationCache()
133 {
134 for (Town *t : Town::Iterate()) t->cache.part_of_subsidy = POS_NONE;
135
136 for (Industry *i : Industry::Iterate()) i->part_of_subsidy = POS_NONE;
137
138 for (const Subsidy *s : Subsidy::Iterate()) {
139 SetPartOfSubsidyFlag(s->src_type, s->src, POS_SRC);
140 SetPartOfSubsidyFlag(s->dst_type, s->dst, POS_DST);
141 }
142 }
143
149 void DeleteSubsidyWith(SourceType type, SourceID index)
150 {
151 bool dirty = false;
152
153 for (Subsidy *s : Subsidy::Iterate()) {
154 if ((s->src_type == type && s->src == index) || (s->dst_type == type && s->dst == index)) {
155 delete s;
156 dirty = true;
157 }
158 }
159
160 if (dirty) {
161 InvalidateWindowData(WC_SUBSIDIES_LIST, 0);
162 RebuildSubsidisedSourceAndDestinationCache();
163 }
164 }
165
175 static bool CheckSubsidyDuplicate(CargoID cargo, SourceType src_type, SourceID src, SourceType dst_type, SourceID dst)
176 {
177 for (const Subsidy *s : Subsidy::Iterate()) {
178 if (s->cargo_type == cargo &&
179 s->src_type == src_type && s->src == src &&
180 s->dst_type == dst_type && s->dst == dst) {
181 return true;
182 }
183 }
184 return false;
185 }
186
195 static bool CheckSubsidyDistance(SourceType src_type, SourceID src, SourceType dst_type, SourceID dst)
196 {
197 TileIndex tile_src = (src_type == ST_TOWN) ? Town::Get(src)->xy : Industry::Get(src)->location.tile;
198 TileIndex tile_dst = (dst_type == ST_TOWN) ? Town::Get(dst)->xy : Industry::Get(dst)->location.tile;
199
200 return (DistanceManhattan(tile_src, tile_dst) <= SUBSIDY_MAX_DISTANCE);
201 }
202
211 void CreateSubsidy(CargoID cid, SourceType src_type, SourceID src, SourceType dst_type, SourceID dst)
212 {
213 Subsidy *s = new Subsidy();
214 s->cargo_type = cid;
215 s->src_type = src_type;
216 s->src = src;
217 s->dst_type = dst_type;
218 s->dst = dst;
219 s->remaining = SUBSIDY_OFFER_MONTHS;
220 s->awarded = INVALID_COMPANY;
221
222 Pair reftype = SetupSubsidyDecodeParam(s, false);
223 AddNewsItem(STR_NEWS_SERVICE_SUBSIDY_OFFERED, NT_SUBSIDIES, NF_NORMAL, (NewsReferenceType)reftype.a, s->src, (NewsReferenceType)reftype.b, s->dst);
224 SetPartOfSubsidyFlag(s->src_type, s->src, POS_SRC);
225 SetPartOfSubsidyFlag(s->dst_type, s->dst, POS_DST);
226 AI::BroadcastNewEvent(new ScriptEventSubsidyOffer(s->index));
227 Game::NewEvent(new ScriptEventSubsidyOffer(s->index));
228
229 InvalidateWindowData(WC_SUBSIDIES_LIST, 0);
230 }
231
246 CommandCost CmdCreateSubsidy(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
247 {
248 if (!Subsidy::CanAllocateItem()) return CMD_ERROR;
249
250 CargoID cid = GB(p1, 24, 8);
251 SourceType src_type = (SourceType)GB(p1, 0, 8);
252 SourceID src = GB(p1, 8, 16);
253 SourceType dst_type = (SourceType)GB(p2, 0, 8);
254 SourceID dst = GB(p2, 8, 16);
255
256 if (_current_company != OWNER_DEITY) return CMD_ERROR;
257
258 if (cid >= NUM_CARGO || !::CargoSpec::Get(cid)->IsValid()) return CMD_ERROR;
259
260 switch (src_type) {
261 case ST_TOWN:
262 if (!Town::IsValidID(src)) return CMD_ERROR;
263 break;
264 case ST_INDUSTRY:
265 if (!Industry::IsValidID(src)) return CMD_ERROR;
266 break;
267 default:
268 return CMD_ERROR;
269 }
270 switch (dst_type) {
271 case ST_TOWN:
272 if (!Town::IsValidID(dst)) return CMD_ERROR;
273 break;
274 case ST_INDUSTRY:
275 if (!Industry::IsValidID(dst)) return CMD_ERROR;
276 break;
277 default:
278 return CMD_ERROR;
279 }
280
281 if (flags & DC_EXEC) {
282 CreateSubsidy(cid, src_type, src, dst_type, dst);
283 }
284
285 return CommandCost();
286 }
287
292 bool FindSubsidyPassengerRoute()
293 {
294 if (!Subsidy::CanAllocateItem()) return false;
295
296 const Town *src = Town::GetRandom();
297 if (src->cache.population < SUBSIDY_PAX_MIN_POPULATION ||
298 src->GetPercentTransported(CT_PASSENGERS) > SUBSIDY_MAX_PCT_TRANSPORTED) {
299 return false;
300 }
301
302 const Town *dst = Town::GetRandom();
303 if (dst->cache.population < SUBSIDY_PAX_MIN_POPULATION || src == dst) {
304 return false;
305 }
306
307 if (DistanceManhattan(src->xy, dst->xy) > SUBSIDY_MAX_DISTANCE) return false;
308 if (CheckSubsidyDuplicate(CT_PASSENGERS, ST_TOWN, src->index, ST_TOWN, dst->index)) return false;
309
310 CreateSubsidy(CT_PASSENGERS, ST_TOWN, src->index, ST_TOWN, dst->index);
311
312 return true;
313 }
314
315 bool FindSubsidyCargoDestination(CargoID cid, SourceType src_type, SourceID src);
316
317
322 bool FindSubsidyTownCargoRoute()
323 {
324 if (!Subsidy::CanAllocateItem()) return false;
325
326 SourceType src_type = ST_TOWN;
327
328 /* Select a random town. */
329 const Town *src_town = Town::GetRandom();
330 if (src_town->cache.population < SUBSIDY_CARGO_MIN_POPULATION) return false;
331
332 /* Calculate the produced cargo of houses around town center. */
333 CargoArray town_cargo_produced;
334 TileArea ta = TileArea(src_town->xy, 1, 1).Expand(SUBSIDY_TOWN_CARGO_RADIUS);
335 TILE_AREA_LOOP(tile, ta) {
336 if (IsTileType(tile, MP_HOUSE)) {
337 AddProducedCargo(tile, town_cargo_produced);
338 }
339 }
340
341 /* Passenger subsidies are not handled here. */
342 town_cargo_produced[CT_PASSENGERS] = 0;
343
344 uint8 cargo_count = 0;
345 for (CargoID i = 0; i < NUM_CARGO; i++) {
346 if (town_cargo_produced[i] > 0) cargo_count++;
347 }
348
349 /* No cargo produced at all? */
350 if (cargo_count == 0) return false;
351
352 /* Choose a random cargo that is produced in the town. */
353 uint8 cargo_number = RandomRange(cargo_count);
354 CargoID cid;
355 for (cid = 0; cid < NUM_CARGO; cid++) {
356 if (town_cargo_produced[cid] > 0) {
357 if (cargo_number == 0) break;
358 cargo_number--;
359 }
360 }
361
362 /* Avoid using invalid NewGRF cargoes. */
363 if (!CargoSpec::Get(cid)->IsValid() ||
364 _settings_game.linkgraph.GetDistributionType(cid) != DT_MANUAL) {
365 return false;
366 }
367
368 /* Quit if the percentage transported is large enough. */
369 if (src_town->GetPercentTransported(cid) > SUBSIDY_MAX_PCT_TRANSPORTED) return false;
370
371 SourceID src = src_town->index;
372
373 return FindSubsidyCargoDestination(cid, src_type, src);
374 }
375
380 bool FindSubsidyIndustryCargoRoute()
381 {
382 if (!Subsidy::CanAllocateItem()) return false;
383
384 SourceType src_type = ST_INDUSTRY;
385
386 /* Select a random industry. */
387 const Industry *src_ind = Industry::GetRandom();
388 if (src_ind == nullptr) return false;
389
390 uint trans, total;
391
392 CargoID cid;
393
394 /* Randomize cargo type */
395 int num_cargos = 0;
396 uint cargo_index;
397 for (cargo_index = 0; cargo_index < lengthof(src_ind->produced_cargo); cargo_index++) {
398 if (src_ind->produced_cargo[cargo_index] != CT_INVALID) num_cargos++;
399 }
400 if (num_cargos == 0) return false; // industry produces nothing
401 int cargo_num = RandomRange(num_cargos) + 1;
402 for (cargo_index = 0; cargo_index < lengthof(src_ind->produced_cargo); cargo_index++) {
403 if (src_ind->produced_cargo[cargo_index] != CT_INVALID) cargo_num--;
404 if (cargo_num == 0) break;
405 }
406 assert(cargo_num == 0); // indicates loop didn't break as intended
407 cid = src_ind->produced_cargo[cargo_index];
408 trans = src_ind->last_month_pct_transported[cargo_index];
409 total = src_ind->last_month_production[cargo_index];
410
411 /* Quit if no production in this industry
412 * or if the pct transported is already large enough
413 * or if the cargo is automatically distributed */
414 if (total == 0 || trans > SUBSIDY_MAX_PCT_TRANSPORTED ||
415 cid == CT_INVALID ||
416 _settings_game.linkgraph.GetDistributionType(cid) != DT_MANUAL) {
417 return false;
418 }
419
420 SourceID src = src_ind->index;
421
422 return FindSubsidyCargoDestination(cid, src_type, src);
423 }
424
432 bool FindSubsidyCargoDestination(CargoID cid, SourceType src_type, SourceID src)
433 {
434 /* Choose a random destination. */
435 SourceType dst_type = Chance16(1, 2) ? ST_TOWN : ST_INDUSTRY;
436
437 SourceID dst;
438 switch (dst_type) {
439 case ST_TOWN: {
440 /* Select a random town. */
441 const Town *dst_town = Town::GetRandom();
442
443 /* Calculate cargo acceptance of houses around town center. */
444 CargoArray town_cargo_accepted;
445 TileArea ta = TileArea(dst_town->xy, 1, 1).Expand(SUBSIDY_TOWN_CARGO_RADIUS);
446 TILE_AREA_LOOP(tile, ta) {
447 if (IsTileType(tile, MP_HOUSE)) {
448 AddAcceptedCargo(tile, town_cargo_accepted, nullptr);
449 }
450 }
451
452 /* Check if the town can accept this cargo. */
453 if (town_cargo_accepted[cid] < 8) return false;
454
455 dst = dst_town->index;
456 break;
457 }
458
459 case ST_INDUSTRY: {
460 /* Select a random industry. */
461 const Industry *dst_ind = Industry::GetRandom();
462 if (dst_ind == nullptr) return false;
463
464 /* The industry must accept the cargo */
465 bool valid = std::find(dst_ind->accepts_cargo, endof(dst_ind->accepts_cargo), cid) != endof(dst_ind->accepts_cargo);
466 if (!valid) return false;
467
468 dst = dst_ind->index;
469 break;
470 }
471
472 default: NOT_REACHED();
473 }
474
475 /* Check that the source and the destination are not the same. */
476 if (src_type == dst_type && src == dst) return false;
477
478 /* Check distance between source and destination. */
479 if (!CheckSubsidyDistance(src_type, src, dst_type, dst)) return false;
480
481 /* Avoid duplicate subsidies. */
482 if (CheckSubsidyDuplicate(cid, src_type, src, dst_type, dst)) return false;
483
484 CreateSubsidy(cid, src_type, src, dst_type, dst);
485
486 return true;
487 }
488
490 void SubsidyMonthlyLoop()
491 {
492 bool modified = false;
493
494 for (Subsidy *s : Subsidy::Iterate()) {
495 if (--s->remaining == 0) {
496 if (!s->IsAwarded()) {
497 Pair reftype = SetupSubsidyDecodeParam(s, true);
498 AddNewsItem(STR_NEWS_OFFER_OF_SUBSIDY_EXPIRED, NT_SUBSIDIES, NF_NORMAL, (NewsReferenceType)reftype.a, s->src, (NewsReferenceType)reftype.b, s->dst);
499 AI::BroadcastNewEvent(new ScriptEventSubsidyOfferExpired(s->index));
500 Game::NewEvent(new ScriptEventSubsidyOfferExpired(s->index));
501 } else {
502 if (s->awarded == _local_company) {
503 Pair reftype = SetupSubsidyDecodeParam(s, true);
504 AddNewsItem(STR_NEWS_SUBSIDY_WITHDRAWN_SERVICE, NT_SUBSIDIES, NF_NORMAL, (NewsReferenceType)reftype.a, s->src, (NewsReferenceType)reftype.b, s->dst);
505 }
506 AI::BroadcastNewEvent(new ScriptEventSubsidyExpired(s->index));
507 Game::NewEvent(new ScriptEventSubsidyExpired(s->index));
508 }
509 delete s;
510 modified = true;
511 }
512 }
513
514 if (modified) {
515 RebuildSubsidisedSourceAndDestinationCache();
516 } else if (_settings_game.linkgraph.distribution_pax != DT_MANUAL &&
517 _settings_game.linkgraph.distribution_mail != DT_MANUAL &&
518 _settings_game.linkgraph.distribution_armoured != DT_MANUAL &&
519 _settings_game.linkgraph.distribution_default != DT_MANUAL) {
520 /* Return early if there are no manually distributed cargoes and if we
521 * don't need to invalidate the subsidies window. */
522 return;
523 }
524
525 bool passenger_subsidy = false;
526 bool town_subsidy = false;
527 bool industry_subsidy = false;
528
529 int random_chance = RandomRange(16);
530
531 if (random_chance < 2 && _settings_game.linkgraph.distribution_pax == DT_MANUAL) {
532 /* There is a 1/8 chance each month of generating a passenger subsidy. */
533 int n = 1000;
534
535 do {
536 passenger_subsidy = FindSubsidyPassengerRoute();
537 } while (!passenger_subsidy && n--);
538 } else if (random_chance == 2) {
539 /* Cargo subsidies with a town as a source have a 1/16 chance. */
540 int n = 1000;
541
542 do {
543 town_subsidy = FindSubsidyTownCargoRoute();
544 } while (!town_subsidy && n--);
545 } else if (random_chance == 3) {
546 /* Cargo subsidies with an industry as a source have a 1/16 chance. */
547 int n = 1000;
548
549 do {
550 industry_subsidy = FindSubsidyIndustryCargoRoute();
551 } while (!industry_subsidy && n--);
552 }
553
554 modified |= passenger_subsidy || town_subsidy || industry_subsidy;
555
556 if (modified) InvalidateWindowData(WC_SUBSIDIES_LIST, 0);
557 }
558
568 bool CheckSubsidised(CargoID cargo_type, CompanyID company, SourceType src_type, SourceID src, const Station *st)
569 {
570 /* If the source isn't subsidised, don't continue */
571 if (src == INVALID_SOURCE) return false;
572 switch (src_type) {
573 case ST_INDUSTRY:
574 if (!(Industry::Get(src)->part_of_subsidy & POS_SRC)) return false;
575 break;
576 case ST_TOWN:
577 if (!(Town::Get(src)->cache.part_of_subsidy & POS_SRC)) return false;
578 break;
579 default: return false;
580 }
581
582 /* Remember all towns near this station (at least one house in its catchment radius)
583 * which are destination of subsidised path. Do that only if needed */
584 std::vector<const Town *> towns_near;
585 if (!st->rect.IsEmpty()) {
586 for (const Subsidy *s : Subsidy::Iterate()) {
587 /* Don't create the cache if there is no applicable subsidy with town as destination */
588 if (s->dst_type != ST_TOWN) continue;
589 if (s->cargo_type != cargo_type || s->src_type != src_type || s->src != src) continue;
590 if (s->IsAwarded() && s->awarded != company) continue;
591
592 BitmapTileIterator it(st->catchment_tiles);
593 for (TileIndex tile = it; tile != INVALID_TILE; tile = ++it) {
594 if (!IsTileType(tile, MP_HOUSE)) continue;
595 const Town *t = Town::GetByTile(tile);
596 if (t->cache.part_of_subsidy & POS_DST) include(towns_near, t);
597 }
598 break;
599 }
600 }
601
602 bool subsidised = false;
603
604 /* Check if there's a (new) subsidy that applies. There can be more subsidies triggered by this delivery!
605 * Think about the case that subsidies are A->B and A->C and station has both B and C in its catchment area */
606 for (Subsidy *s : Subsidy::Iterate()) {
607 if (s->cargo_type == cargo_type && s->src_type == src_type && s->src == src && (!s->IsAwarded() || s->awarded == company)) {
608 switch (s->dst_type) {
609 case ST_INDUSTRY:
610 for (Industry *ind : st->industries_near) {
611 if (s->dst == ind->index) {
612 assert(ind->part_of_subsidy & POS_DST);
613 subsidised = true;
614 if (!s->IsAwarded()) s->AwardTo(company);
615 }
616 }
617 break;
618 case ST_TOWN:
619 for (const Town *tp : towns_near) {
620 if (s->dst == tp->index) {
621 assert(tp->cache.part_of_subsidy & POS_DST);
622 subsidised = true;
623 if (!s->IsAwarded()) s->AwardTo(company);
624 }
625 }
626 break;
627 default:
628 NOT_REACHED();
629 }
630 }
631 }
632
633 return subsidised;
634 }
Pair
A pair of two integers.
Definition: geometry_type.hpp:66
game.hpp
MP_HOUSE
@ MP_HOUSE
A house by a town.
Definition: tile_type.h:44
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
InvalidateWindowData
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3321
CmdCreateSubsidy
CommandCost CmdCreateSubsidy(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Create a new subsidy.
Definition: subsidy.cpp:246
CheckSubsidyDuplicate
static bool CheckSubsidyDuplicate(CargoID cargo, SourceType src_type, SourceID src, SourceType dst_type, SourceID dst)
Check whether a specific subsidy already exists.
Definition: subsidy.cpp:175
Chance16
static bool Chance16(const uint a, const uint b)
Flips a coin with given probability.
Definition: random_func.hpp:131
Pool::PoolItem<&_industry_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:329
Industry::part_of_subsidy
PartOfSubsidy part_of_subsidy
NOSAVE: is this industry a source/destination of a subsidy?
Definition: industry.h:90
GB
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
Definition: bitmath_func.hpp:32
command_func.h
CMD_ERROR
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition: command_func.h:23
NT_SUBSIDIES
@ NT_SUBSIDIES
News about subsidies (announcements, expirations, acceptance)
Definition: news_type.h:35
WC_SUBSIDIES_LIST
@ WC_SUBSIDIES_LIST
Subsidies list; Window numbers:
Definition: window_type.h:253
Station
Station data structure.
Definition: station_base.h:450
BitmapTileIterator
Iterator to iterate over all tiles belonging to a bitmaptilearea.
Definition: bitmap_type.h:107
SUBSIDY_OFFER_MONTHS
static const uint SUBSIDY_OFFER_MONTHS
Constants related to subsidies.
Definition: subsidy_base.h:54
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:227
CargoSpec::Get
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo ID.
Definition: cargotype.h:117
LinkGraphSettings::distribution_mail
DistributionType distribution_mail
distribution type for mail
Definition: settings_type.h:513
SUBSIDY_MAX_PCT_TRANSPORTED
static const uint SUBSIDY_MAX_PCT_TRANSPORTED
Subsidy will be created only for towns/industries with less % transported.
Definition: subsidy_base.h:58
CargoArray
Class for storing amounts of cargo.
Definition: cargo_type.h:81
DT_MANUAL
@ DT_MANUAL
Manual distribution. No link graph calculations are run.
Definition: linkgraph_type.h:25
GameSettings::difficulty
DifficultySettings difficulty
settings related to the difficulty
Definition: settings_type.h:559
Industry::last_month_production
uint16 last_month_production[INDUSTRY_NUM_OUTPUTS]
total units produced per cargo in the last full month
Definition: industry.h:79
include
bool include(std::vector< T > &vec, const T &item)
Helper function to append an item to a vector if it is not already contained Consider using std::set,...
Definition: smallvec_type.hpp:27
valid
uint8 valid
Bits indicating what variable is valid (for each bit, 0 is invalid, 1 is valid).
Definition: newgrf_station.cpp:248
SUBSIDY_CONTRACT_MONTHS
static const uint SUBSIDY_CONTRACT_MONTHS
Duration of subsidy after awarding.
Definition: subsidy_base.h:55
TownCache::part_of_subsidy
PartOfSubsidy part_of_subsidy
Is this town a source/destination of a subsidy?
Definition: town.h:44
Town::xy
TileIndex xy
town center tile
Definition: town.h:51
CargoSpec
Specification of a cargo type.
Definition: cargotype.h:55
town.h
RandomRange
static uint32 RandomRange(uint32 limit)
Pick a random number between 0 and limit - 1, inclusive.
Definition: random_func.hpp:81
Industry
Defines the internal data of a functional industry.
Definition: industry.h:66
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
DC_EXEC
@ DC_EXEC
execute the given command
Definition: command_type.h:348
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:199
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:346
Town::GetRandom
static Town * GetRandom()
Return a random valid town.
Definition: town_cmd.cpp:178
FindSubsidyTownCargoRoute
bool FindSubsidyTownCargoRoute()
Tries to create a cargo subsidy with a town as source.
Definition: subsidy.cpp:322
ST_TOWN
@ ST_TOWN
Source/destination is a town.
Definition: cargo_type.h:148
MAX_CHAR_LENGTH
static const int MAX_CHAR_LENGTH
Max. length of UTF-8 encoded unicode character.
Definition: strings_type.h:18
MAX_LENGTH_COMPANY_NAME_CHARS
static const uint MAX_LENGTH_COMPANY_NAME_CHARS
The maximum length of a company name in characters including '\0'.
Definition: company_type.h:40
ai.hpp
tile_cmd.h
Industry::GetRandom
static Industry * GetRandom()
Return a random valid industry.
Definition: industry_cmd.cpp:218
DistanceManhattan
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition: map.cpp:157
TownCache::population
uint32 population
Current population of people.
Definition: town.h:42
SUBSIDY_CARGO_MIN_POPULATION
static const uint SUBSIDY_CARGO_MIN_POPULATION
Min. population of destination town for cargo route.
Definition: subsidy_base.h:57
Subsidy::cargo_type
CargoID cargo_type
Cargo type involved in this subsidy, CT_INVALID for invalid subsidy.
Definition: subsidy_base.h:23
Subsidy
Struct about subsidies, offered and awarded.
Definition: subsidy_base.h:22
DifficultySettings::subsidy_multiplier
byte subsidy_multiplier
amount of subsidy
Definition: settings_type.h:72
SUBSIDY_TOWN_CARGO_RADIUS
static const uint SUBSIDY_TOWN_CARGO_RADIUS
Extent of a tile area around town center when scanning for town cargo acceptance and production (6 ~=...
Definition: subsidy_base.h:60
CommandCost
Common return value for all commands.
Definition: command_type.h:23
SourceID
uint16 SourceID
Contains either industry ID, town ID or company ID (or INVALID_SOURCE)
Definition: cargo_type.h:152
TILE_AREA_LOOP
#define TILE_AREA_LOOP(var, ta)
A loop which iterates over the tiles of a TileArea.
Definition: tilearea_type.h:232
FindSubsidyIndustryCargoRoute
bool FindSubsidyIndustryCargoRoute()
Tries to create a cargo subsidy with an industry as source.
Definition: subsidy.cpp:380
BaseStation::rect
StationRect rect
NOSAVE: Station spread out rectangle maintained by StationRect::xxx() functions.
Definition: base_station_base.h:76
Subsidy::src
SourceID src
Index of source. Either TownID or IndustryID.
Definition: subsidy_base.h:28
Industry::produced_cargo
CargoID produced_cargo[INDUSTRY_NUM_OUTPUTS]
16 production cargo slots
Definition: industry.h:70
SetPartOfSubsidyFlag
static void SetPartOfSubsidyFlag(SourceType type, SourceID index, PartOfSubsidy flag)
Sets a flag indicating that given town/industry is part of subsidised route.
Definition: subsidy.cpp:122
ST_INDUSTRY
@ ST_INDUSTRY
Source/destination is an industry.
Definition: cargo_type.h:147
OrthogonalTileArea
Represents the covered area of e.g.
Definition: tilearea_type.h:16
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:80
DeleteSubsidyWith
void DeleteSubsidyWith(SourceType type, SourceID index)
Delete the subsidies associated with a given cargo source type and id.
Definition: subsidy.cpp:149
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:141
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
AI::BroadcastNewEvent
static void BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company=MAX_COMPANIES)
Broadcast a new event to all active AIs.
Definition: ai_core.cpp:259
industry.h
safeguards.h
_subsidy_pool
SubsidyPool _subsidy_pool("Subsidy")
Pool for the subsidies.
Subsidy::dst
SourceID dst
Index of destination. Either TownID or IndustryID.
Definition: subsidy_base.h:29
InjectDParam
void InjectDParam(uint amount)
Shift the string parameters in the global string parameter array by amount positions,...
Definition: strings.cpp:295
GameSettings::linkgraph
LinkGraphSettings linkgraph
settings for link graph calculations
Definition: settings_type.h:570
stdafx.h
NR_NONE
@ NR_NONE
Empty reference.
Definition: news_type.h:50
NF_NORMAL
@ NF_NORMAL
Normal news item. (Newspaper with text only)
Definition: news_type.h:78
IsTileType
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
Industry::last_month_pct_transported
byte last_month_pct_transported[INDUSTRY_NUM_OUTPUTS]
percentage transported per cargo in the last full month
Definition: industry.h:78
NewsReferenceType
NewsReferenceType
References to objects in news.
Definition: news_type.h:49
string_func.h
NR_TOWN
@ NR_TOWN
Reference town. Scroll to town when clicking on the news.
Definition: news_type.h:55
Subsidy::dst_type
SourceType dst_type
Destination of subsidised path (ST_INDUSTRY or ST_TOWN)
Definition: subsidy_base.h:27
Station::industries_near
IndustryList industries_near
Cached list of industries near the station that can accept cargo,.
Definition: station_base.h:482
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
station_base.h
SourceType
SourceType
Types of cargo source and destination.
Definition: cargo_type.h:146
Pool::PoolItem<&_town_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:378
strings_func.h
Pool
Base class for all pools.
Definition: pool_type.hpp:81
SetupSubsidyDecodeParam
Pair SetupSubsidyDecodeParam(const Subsidy *s, bool mode)
Setup the string parameters for printing the subsidy at the screen, and compute the news reference fo...
Definition: subsidy.cpp:75
Subsidy::remaining
byte remaining
Remaining months when this subsidy is valid.
Definition: subsidy_base.h:24
subsidy_func.h
RebuildSubsidisedSourceAndDestinationCache
void RebuildSubsidisedSourceAndDestinationCache()
Perform a full rebuild of the subsidies cache.
Definition: subsidy.cpp:132
SUBSIDY_MAX_DISTANCE
static const uint SUBSIDY_MAX_DISTANCE
Max. length of subsidised route (DistanceManhattan)
Definition: subsidy_base.h:59
endof
#define endof(x)
Get the end element of an fixed size array.
Definition: stdafx.h:375
NUM_CARGO
@ NUM_CARGO
Maximal number of cargo types in a game.
Definition: cargo_type.h:64
Town::cache
TownCache cache
Container for all cacheable data.
Definition: town.h:53
Pool::PoolItem<&_subsidy_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:299
INVALID_SOURCE
static const SourceID INVALID_SOURCE
Invalid/unknown index of source.
Definition: cargo_type.h:153
POS_NONE
@ POS_NONE
nothing
Definition: subsidy_type.h:17
subsidy_base.h
CargoSpec::name
StringID name
Name of this type of cargo.
Definition: cargotype.h:70
Station::catchment_tiles
BitmapTileArea catchment_tiles
NOSAVE: Set of individual tiles covered by catchment area.
Definition: station_base.h:470
OWNER_DEITY
@ OWNER_DEITY
The object is owned by a superuser / goal script.
Definition: company_type.h:27
PartOfSubsidy
PartOfSubsidy
What part of a subsidy is something?
Definition: subsidy_type.h:16
company_func.h
FindSubsidyCargoDestination
bool FindSubsidyCargoDestination(CargoID cid, SourceType src_type, SourceID src)
Tries to find a suitable destination for the given source and cargo.
Definition: subsidy.cpp:432
CargoSpec::name_single
StringID name_single
Name of a single entity of this type of cargo.
Definition: cargotype.h:71
INSTANTIATE_POOL_METHODS
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
Definition: pool_func.hpp:224
stredup
char * stredup(const char *s, const char *last)
Create a duplicate of the given string.
Definition: string.cpp:137
TileArea
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
Definition: tilearea_type.h:96
AddNewsItem
void AddNewsItem(StringID string, NewsType type, NewsFlag flags, NewsReferenceType reftype1=NR_NONE, uint32 ref1=UINT32_MAX, NewsReferenceType reftype2=NR_NONE, uint32 ref2=UINT32_MAX, void *free_data=nullptr)
Add a new newsitem to be shown.
Definition: news_gui.cpp:789
window_func.h
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:367
Town
Town data structure.
Definition: town.h:50
CreateSubsidy
void CreateSubsidy(CargoID cid, SourceType src_type, SourceID src, SourceType dst_type, SourceID dst)
Creates a subsidy with the given parameters.
Definition: subsidy.cpp:211
random_func.hpp
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
INVALID_TILE
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:83
INVALID_COMPANY
@ INVALID_COMPANY
An invalid company.
Definition: company_type.h:30
OrthogonalTileArea::Expand
OrthogonalTileArea & Expand(int rad)
Expand a tile area by rad tiles in each direction, keeping within map bounds.
Definition: tilearea.cpp:123
Industry::accepts_cargo
CargoID accepts_cargo[INDUSTRY_NUM_INPUTS]
16 input cargo slots
Definition: industry.h:75
Pool::PoolItem<&_town_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:318
LinkGraphSettings::distribution_armoured
DistributionType distribution_armoured
distribution type for armoured cargo class
Definition: settings_type.h:514
CheckSubsidised
bool CheckSubsidised(CargoID cargo_type, CompanyID company, SourceType src_type, SourceID src, const Station *st)
Tests whether given delivery is subsidised and possibly awards the subsidy to delivering company.
Definition: subsidy.cpp:568
pool_func.hpp
CT_INVALID
@ CT_INVALID
Invalid cargo type.
Definition: cargo_type.h:68
Subsidy::src_type
SourceType src_type
Source of subsidised path (ST_INDUSTRY or ST_TOWN)
Definition: subsidy_base.h:26
NR_INDUSTRY
@ NR_INDUSTRY
Reference industry. Scroll to industry when clicking on the news. Delete news when industry is delete...
Definition: news_type.h:54
lastof
#define lastof(x)
Get the last element of an fixed size array.
Definition: stdafx.h:383
Subsidy::awarded
CompanyID awarded
Subsidy is awarded to this company; INVALID_COMPANY if it's not awarded to anyone.
Definition: subsidy_base.h:25
CheckSubsidyDistance
static bool CheckSubsidyDistance(SourceType src_type, SourceID src, SourceType dst_type, SourceID dst)
Checks if the source and destination of a subsidy are inside the distance limit.
Definition: subsidy.cpp:195
LinkGraphSettings::distribution_pax
DistributionType distribution_pax
distribution type for passengers
Definition: settings_type.h:512
SetDParamStr
void SetDParamStr(uint n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition: strings.cpp:286
SubsidyMonthlyLoop
void SubsidyMonthlyLoop()
Perform the monthly update of open subsidies, and try to create a new one.
Definition: subsidy.cpp:490
POS_DST
@ POS_DST
bit 1 set -> town/industry is destination of subsidised path
Definition: subsidy_type.h:19
LinkGraphSettings::distribution_default
DistributionType distribution_default
distribution type for all other goods
Definition: settings_type.h:515
POS_SRC
@ POS_SRC
bit 0 set -> town/industry is source of subsidised path
Definition: subsidy_type.h:18
SUBSIDY_PAX_MIN_POPULATION
static const uint SUBSIDY_PAX_MIN_POPULATION
Min. population of towns for subsidised pax route.
Definition: subsidy_base.h:56
news_func.h
FindSubsidyPassengerRoute
bool FindSubsidyPassengerRoute()
Tries to create a passenger subsidy between two towns.
Definition: subsidy.cpp:292