OpenTTD
subsidy.cpp
Go to the documentation of this file.
1 /* $Id: subsidy.cpp 26509 2014-04-25 15:40:32Z rubidium $ */
2 
3 /*
4  * This file is part of OpenTTD.
5  * 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.
6  * 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.
7  * 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/>.
8  */
9 
12 #include "stdafx.h"
13 #include "company_func.h"
14 #include "industry.h"
15 #include "town.h"
16 #include "news_func.h"
17 #include "ai/ai.hpp"
18 #include "station_base.h"
19 #include "strings_func.h"
20 #include "window_func.h"
21 #include "subsidy_base.h"
22 #include "subsidy_func.h"
23 #include "core/pool_func.hpp"
24 #include "core/random_func.hpp"
25 #include "game/game.hpp"
26 #include "command_func.h"
27 #include "string_func.h"
28 
29 #include "table/strings.h"
30 
31 #include "safeguards.h"
32 
33 SubsidyPool _subsidy_pool("Subsidy");
35 
36 
40 void Subsidy::AwardTo(CompanyID company)
41 {
42  assert(!this->IsAwarded());
43 
44  this->awarded = company;
45  this->remaining = SUBSIDY_CONTRACT_MONTHS;
46 
48  SetDParam(0, company);
49  GetString(company_name, STR_COMPANY_NAME, lastof(company_name));
50 
51  char *cn = stredup(company_name);
52 
53  /* Add a news item */
54  Pair reftype = SetupSubsidyDecodeParam(this, false);
55  InjectDParam(1);
56 
57  SetDParamStr(0, cn);
59  STR_NEWS_SERVICE_SUBSIDY_AWARDED_HALF + _settings_game.difficulty.subsidy_multiplier,
61  (NewsReferenceType)reftype.a, this->src, (NewsReferenceType)reftype.b, this->dst,
62  cn
63  );
64  AI::BroadcastNewEvent(new ScriptEventSubsidyAwarded(this->index));
65  Game::NewEvent(new ScriptEventSubsidyAwarded(this->index));
66 
68 }
69 
76 Pair SetupSubsidyDecodeParam(const Subsidy *s, bool mode)
77 {
78  NewsReferenceType reftype1 = NR_NONE;
79  NewsReferenceType reftype2 = NR_NONE;
80 
81  /* if mode is false, use the singular form */
82  const CargoSpec *cs = CargoSpec::Get(s->cargo_type);
83  SetDParam(0, mode ? cs->name : cs->name_single);
84 
85  switch (s->src_type) {
86  case ST_INDUSTRY:
87  reftype1 = NR_INDUSTRY;
88  SetDParam(1, STR_INDUSTRY_NAME);
89  break;
90  case ST_TOWN:
91  reftype1 = NR_TOWN;
92  SetDParam(1, STR_TOWN_NAME);
93  break;
94  default: NOT_REACHED();
95  }
96  SetDParam(2, s->src);
97 
98  switch (s->dst_type) {
99  case ST_INDUSTRY:
100  reftype2 = NR_INDUSTRY;
101  SetDParam(4, STR_INDUSTRY_NAME);
102  break;
103  case ST_TOWN:
104  reftype2 = NR_TOWN;
105  SetDParam(4, STR_TOWN_NAME);
106  break;
107  default: NOT_REACHED();
108  }
109  SetDParam(5, s->dst);
110 
111  Pair p;
112  p.a = reftype1;
113  p.b = reftype2;
114  return p;
115 }
116 
123 static inline void SetPartOfSubsidyFlag(SourceType type, SourceID index, PartOfSubsidy flag)
124 {
125  switch (type) {
126  case ST_INDUSTRY: Industry::Get(index)->part_of_subsidy |= flag; return;
127  case ST_TOWN: Town::Get(index)->cache.part_of_subsidy |= flag; return;
128  default: NOT_REACHED();
129  }
130 }
131 
134 {
135  Town *t;
136  FOR_ALL_TOWNS(t) t->cache.part_of_subsidy = POS_NONE;
137 
138  Industry *i;
139  FOR_ALL_INDUSTRIES(i) i->part_of_subsidy = POS_NONE;
140 
141  const Subsidy *s;
142  FOR_ALL_SUBSIDIES(s) {
145  }
146 }
147 
154 {
155  bool dirty = false;
156 
157  Subsidy *s;
158  FOR_ALL_SUBSIDIES(s) {
159  if ((s->src_type == type && s->src == index) || (s->dst_type == type && s->dst == index)) {
160  delete s;
161  dirty = true;
162  }
163  }
164 
165  if (dirty) {
168  }
169 }
170 
180 static bool CheckSubsidyDuplicate(CargoID cargo, SourceType src_type, SourceID src, SourceType dst_type, SourceID dst)
181 {
182  const Subsidy *s;
183  FOR_ALL_SUBSIDIES(s) {
184  if (s->cargo_type == cargo &&
185  s->src_type == src_type && s->src == src &&
186  s->dst_type == dst_type && s->dst == dst) {
187  return true;
188  }
189  }
190  return false;
191 }
192 
201 static bool CheckSubsidyDistance(SourceType src_type, SourceID src, SourceType dst_type, SourceID dst)
202 {
203  TileIndex tile_src = (src_type == ST_TOWN) ? Town::Get(src)->xy : Industry::Get(src)->location.tile;
204  TileIndex tile_dst = (dst_type == ST_TOWN) ? Town::Get(dst)->xy : Industry::Get(dst)->location.tile;
205 
206  return (DistanceManhattan(tile_src, tile_dst) <= SUBSIDY_MAX_DISTANCE);
207 }
208 
217 void CreateSubsidy(CargoID cid, SourceType src_type, SourceID src, SourceType dst_type, SourceID dst)
218 {
219  Subsidy *s = new Subsidy();
220  s->cargo_type = cid;
221  s->src_type = src_type;
222  s->src = src;
223  s->dst_type = dst_type;
224  s->dst = dst;
227 
228  Pair reftype = SetupSubsidyDecodeParam(s, false);
229  AddNewsItem(STR_NEWS_SERVICE_SUBSIDY_OFFERED, NT_SUBSIDIES, NF_NORMAL, (NewsReferenceType)reftype.a, s->src, (NewsReferenceType)reftype.b, s->dst);
232  AI::BroadcastNewEvent(new ScriptEventSubsidyOffer(s->index));
233  Game::NewEvent(new ScriptEventSubsidyOffer(s->index));
234 
236 }
237 
252 CommandCost CmdCreateSubsidy(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
253 {
254  if (!Subsidy::CanAllocateItem()) return CMD_ERROR;
255 
256  CargoID cid = GB(p1, 24, 8);
257  SourceType src_type = (SourceType)GB(p1, 0, 8);
258  SourceID src = GB(p1, 8, 16);
259  SourceType dst_type = (SourceType)GB(p2, 0, 8);
260  SourceID dst = GB(p2, 8, 16);
261 
262  if (_current_company != OWNER_DEITY) return CMD_ERROR;
263 
264  if (cid >= NUM_CARGO || !::CargoSpec::Get(cid)->IsValid()) return CMD_ERROR;
265 
266  switch (src_type) {
267  case ST_TOWN:
268  if (!Town::IsValidID(src)) return CMD_ERROR;
269  break;
270  case ST_INDUSTRY:
271  if (!Industry::IsValidID(src)) return CMD_ERROR;
272  break;
273  default:
274  return CMD_ERROR;
275  }
276  switch (dst_type) {
277  case ST_TOWN:
278  if (!Town::IsValidID(dst)) return CMD_ERROR;
279  break;
280  case ST_INDUSTRY:
281  if (!Industry::IsValidID(dst)) return CMD_ERROR;
282  break;
283  default:
284  return CMD_ERROR;
285  }
286 
287  if (flags & DC_EXEC) {
288  CreateSubsidy(cid, src_type, src, dst_type, dst);
289  }
290 
291  return CommandCost();
292 }
293 
299 {
300  if (!Subsidy::CanAllocateItem()) return false;
301 
302  const Town *src = Town::GetRandom();
304  src->GetPercentTransported(CT_PASSENGERS) > SUBSIDY_MAX_PCT_TRANSPORTED) {
305  return false;
306  }
307 
308  const Town *dst = Town::GetRandom();
309  if (dst->cache.population < SUBSIDY_PAX_MIN_POPULATION || src == dst) {
310  return false;
311  }
312 
313  if (DistanceManhattan(src->xy, dst->xy) > SUBSIDY_MAX_DISTANCE) return false;
314  if (CheckSubsidyDuplicate(CT_PASSENGERS, ST_TOWN, src->index, ST_TOWN, dst->index)) return false;
315 
316  CreateSubsidy(CT_PASSENGERS, ST_TOWN, src->index, ST_TOWN, dst->index);
317 
318  return true;
319 }
320 
321 bool FindSubsidyCargoDestination(CargoID cid, SourceType src_type, SourceID src);
322 
323 
329 {
330  if (!Subsidy::CanAllocateItem()) return false;
331 
332  SourceType src_type = ST_TOWN;
333 
334  /* Select a random town. */
335  const Town *src_town = Town::GetRandom();
336 
337  uint32 town_cargo_produced = src_town->cargo_produced;
338 
339  /* Passenger subsidies are not handled here. */
340  ClrBit(town_cargo_produced, CT_PASSENGERS);
341 
342  /* No cargo produced at all? */
343  if (town_cargo_produced == 0) return false;
344 
345  /* Choose a random cargo that is produced in the town. */
346  uint8 cargo_number = RandomRange(CountBits(town_cargo_produced));
347  CargoID cid;
348  FOR_EACH_SET_CARGO_ID(cid, town_cargo_produced) {
349  if (cargo_number == 0) break;
350  cargo_number--;
351  }
352 
353  /* Avoid using invalid NewGRF cargoes. */
354  if (!CargoSpec::Get(cid)->IsValid() ||
355  _settings_game.linkgraph.GetDistributionType(cid) != DT_MANUAL) {
356  return false;
357  }
358 
359  /* Quit if the percentage transported is large enough. */
360  if (src_town->GetPercentTransported(cid) > SUBSIDY_MAX_PCT_TRANSPORTED) return false;
361 
362  SourceID src = src_town->index;
363 
364  return FindSubsidyCargoDestination(cid, src_type, src);
365 }
366 
372 {
373  if (!Subsidy::CanAllocateItem()) return false;
374 
375  SourceType src_type = ST_INDUSTRY;
376 
377  /* Select a random industry. */
378  const Industry *src_ind = Industry::GetRandom();
379  if (src_ind == NULL) return false;
380 
381  uint trans, total;
382 
383  CargoID cid;
384 
385  /* Randomize cargo type */
386  if (src_ind->produced_cargo[1] != CT_INVALID && HasBit(Random(), 0)) {
387  cid = src_ind->produced_cargo[1];
388  trans = src_ind->last_month_pct_transported[1];
389  total = src_ind->last_month_production[1];
390  } else {
391  cid = src_ind->produced_cargo[0];
392  trans = src_ind->last_month_pct_transported[0];
393  total = src_ind->last_month_production[0];
394  }
395 
396  /* Quit if no production in this industry
397  * or if the pct transported is already large enough
398  * or if the cargo is automatically distributed */
399  if (total == 0 || trans > SUBSIDY_MAX_PCT_TRANSPORTED ||
400  cid == CT_INVALID ||
401  _settings_game.linkgraph.GetDistributionType(cid) != DT_MANUAL) {
402  return false;
403  }
404 
405  SourceID src = src_ind->index;
406 
407  return FindSubsidyCargoDestination(cid, src_type, src);
408 }
409 
418 {
419  /* Choose a random destination. Only consider towns if they can accept the cargo. */
420  SourceType dst_type = (HasBit(_town_cargoes_accepted, cid) && Chance16(1, 2)) ? ST_TOWN : ST_INDUSTRY;
421 
422  SourceID dst;
423  switch (dst_type) {
424  case ST_TOWN: {
425  /* Select a random town. */
426  const Town *dst_town = Town::GetRandom();
427 
428  /* Check if the town can accept this cargo. */
429  if (!HasBit(dst_town->cargo_accepted_total, cid)) return false;
430 
431  dst = dst_town->index;
432  break;
433  }
434 
435  case ST_INDUSTRY: {
436  /* Select a random industry. */
437  const Industry *dst_ind = Industry::GetRandom();
438 
439  /* The industry must accept the cargo */
440  if (dst_ind == NULL ||
441  (cid != dst_ind->accepts_cargo[0] &&
442  cid != dst_ind->accepts_cargo[1] &&
443  cid != dst_ind->accepts_cargo[2])) {
444  return false;
445  }
446 
447  dst = dst_ind->index;
448  break;
449  }
450 
451  default: NOT_REACHED();
452  }
453 
454  /* Check that the source and the destination are not the same. */
455  if (src_type == dst_type && src == dst) return false;
456 
457  /* Check distance between source and destination. */
458  if (!CheckSubsidyDistance(src_type, src, dst_type, dst)) return false;
459 
460  /* Avoid duplicate subsidies. */
461  if (CheckSubsidyDuplicate(cid, src_type, src, dst_type, dst)) return false;
462 
463  CreateSubsidy(cid, src_type, src, dst_type, dst);
464 
465  return true;
466 }
467 
470 {
471  bool modified = false;
472 
473  Subsidy *s;
474  FOR_ALL_SUBSIDIES(s) {
475  if (--s->remaining == 0) {
476  if (!s->IsAwarded()) {
477  Pair reftype = SetupSubsidyDecodeParam(s, true);
478  AddNewsItem(STR_NEWS_OFFER_OF_SUBSIDY_EXPIRED, NT_SUBSIDIES, NF_NORMAL, (NewsReferenceType)reftype.a, s->src, (NewsReferenceType)reftype.b, s->dst);
479  AI::BroadcastNewEvent(new ScriptEventSubsidyOfferExpired(s->index));
480  Game::NewEvent(new ScriptEventSubsidyOfferExpired(s->index));
481  } else {
482  if (s->awarded == _local_company) {
483  Pair reftype = SetupSubsidyDecodeParam(s, true);
484  AddNewsItem(STR_NEWS_SUBSIDY_WITHDRAWN_SERVICE, NT_SUBSIDIES, NF_NORMAL, (NewsReferenceType)reftype.a, s->src, (NewsReferenceType)reftype.b, s->dst);
485  }
486  AI::BroadcastNewEvent(new ScriptEventSubsidyExpired(s->index));
487  Game::NewEvent(new ScriptEventSubsidyExpired(s->index));
488  }
489  delete s;
490  modified = true;
491  }
492  }
493 
494  if (modified) {
500  /* Return early if there are no manually distributed cargoes and if we
501  * don't need to invalidate the subsidies window. */
502  return;
503  }
504 
505  bool passenger_subsidy = false;
506  bool town_subsidy = false;
507  bool industry_subsidy = false;
508 
509  int random_chance = RandomRange(16);
510 
511  if (random_chance < 2 && _settings_game.linkgraph.distribution_pax == DT_MANUAL) {
512  /* There is a 1/8 chance each month of generating a passenger subsidy. */
513  int n = 1000;
514 
515  do {
516  passenger_subsidy = FindSubsidyPassengerRoute();
517  } while (!passenger_subsidy && n--);
518  } else if (random_chance == 2) {
519  /* Cargo subsidies with a town as a source have a 1/16 chance. */
520  int n = 1000;
521 
522  do {
523  town_subsidy = FindSubsidyTownCargoRoute();
524  } while (!town_subsidy && n--);
525  } else if (random_chance == 3) {
526  /* Cargo subsidies with an industry as a source have a 1/16 chance. */
527  int n = 1000;
528 
529  do {
530  industry_subsidy = FindSubsidyIndustryCargoRoute();
531  } while (!industry_subsidy && n--);
532  }
533 
534  modified |= passenger_subsidy || town_subsidy || industry_subsidy;
535 
536  if (modified) InvalidateWindowData(WC_SUBSIDIES_LIST, 0);
537 }
538 
548 bool CheckSubsidised(CargoID cargo_type, CompanyID company, SourceType src_type, SourceID src, const Station *st)
549 {
550  /* If the source isn't subsidised, don't continue */
551  if (src == INVALID_SOURCE) return false;
552  switch (src_type) {
553  case ST_INDUSTRY:
554  if (!(Industry::Get(src)->part_of_subsidy & POS_SRC)) return false;
555  break;
556  case ST_TOWN:
557  if (!(Town::Get(src)->cache.part_of_subsidy & POS_SRC)) return false;
558  break;
559  default: return false;
560  }
561 
562  /* Remember all towns near this station (at least one house in its catchment radius)
563  * which are destination of subsidised path. Do that only if needed */
564  SmallVector<const Town *, 2> towns_near;
565  if (!st->rect.IsEmpty()) {
566  Subsidy *s;
567  FOR_ALL_SUBSIDIES(s) {
568  /* Don't create the cache if there is no applicable subsidy with town as destination */
569  if (s->dst_type != ST_TOWN) continue;
570  if (s->cargo_type != cargo_type || s->src_type != src_type || s->src != src) continue;
571  if (s->IsAwarded() && s->awarded != company) continue;
572 
573  Rect rect = st->GetCatchmentRect();
574 
575  for (int y = rect.top; y <= rect.bottom; y++) {
576  for (int x = rect.left; x <= rect.right; x++) {
577  TileIndex tile = TileXY(x, y);
578  if (!IsTileType(tile, MP_HOUSE)) continue;
579  const Town *t = Town::GetByTile(tile);
580  if (t->cache.part_of_subsidy & POS_DST) towns_near.Include(t);
581  }
582  }
583  break;
584  }
585  }
586 
587  bool subsidised = false;
588 
589  /* Check if there's a (new) subsidy that applies. There can be more subsidies triggered by this delivery!
590  * Think about the case that subsidies are A->B and A->C and station has both B and C in its catchment area */
591  Subsidy *s;
592  FOR_ALL_SUBSIDIES(s) {
593  if (s->cargo_type == cargo_type && s->src_type == src_type && s->src == src && (!s->IsAwarded() || s->awarded == company)) {
594  switch (s->dst_type) {
595  case ST_INDUSTRY:
596  for (const Industry * const *ip = st->industries_near.Begin(); ip != st->industries_near.End(); ip++) {
597  if (s->dst == (*ip)->index) {
598  assert((*ip)->part_of_subsidy & POS_DST);
599  subsidised = true;
600  if (!s->IsAwarded()) s->AwardTo(company);
601  }
602  }
603  break;
604  case ST_TOWN:
605  for (const Town * const *tp = towns_near.Begin(); tp != towns_near.End(); tp++) {
606  if (s->dst == (*tp)->index) {
607  assert((*tp)->cache.part_of_subsidy & POS_DST);
608  subsidised = true;
609  if (!s->IsAwarded()) s->AwardTo(company);
610  }
611  }
612  break;
613  default:
614  NOT_REACHED();
615  }
616  }
617  }
618 
619  return subsidised;
620 }