OpenTTD Source  20241120-master-g6d3adc6169
economy.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 "command_func.h"
13 #include "industry.h"
14 #include "town.h"
15 #include "news_func.h"
16 #include "network/network.h"
17 #include "network/network_func.h"
18 #include "ai/ai.hpp"
19 #include "aircraft.h"
20 #include "train.h"
21 #include "newgrf_engine.h"
22 #include "engine_base.h"
23 #include "ground_vehicle.hpp"
24 #include "newgrf_cargo.h"
25 #include "newgrf_sound.h"
26 #include "newgrf_industrytiles.h"
27 #include "newgrf_station.h"
28 #include "newgrf_airporttiles.h"
29 #include "newgrf_roadstop.h"
30 #include "object.h"
31 #include "strings_func.h"
32 #include "vehicle_func.h"
33 #include "sound_func.h"
34 #include "autoreplace_func.h"
35 #include "company_gui.h"
36 #include "signs_base.h"
37 #include "subsidy_base.h"
38 #include "subsidy_func.h"
39 #include "station_base.h"
40 #include "waypoint_base.h"
41 #include "economy_base.h"
42 #include "core/pool_func.hpp"
43 #include "core/backup_type.hpp"
44 #include "core/container_func.hpp"
45 #include "cargo_type.h"
46 #include "water.h"
47 #include "game/game.hpp"
48 #include "cargomonitor.h"
49 #include "goal_base.h"
50 #include "story_base.h"
51 #include "linkgraph/refresh.h"
52 #include "company_cmd.h"
53 #include "economy_cmd.h"
54 #include "vehicle_cmd.h"
55 #include "timer/timer.h"
58 
59 #include "table/strings.h"
60 #include "table/pricebase.h"
61 
62 #include "safeguards.h"
63 
64 
65 /* Initialize the cargo payment-pool */
68 
69 
80 static inline int32_t BigMulS(const int32_t a, const int32_t b, const uint8_t shift)
81 {
82  return (int32_t)((int64_t)a * (int64_t)b >> shift);
83 }
84 
85 typedef std::vector<Industry *> SmallIndustryList;
86 
91  { 120, 100}, // SCORE_VEHICLES
92  { 80, 100}, // SCORE_STATIONS
93  { 10000, 100}, // SCORE_MIN_PROFIT
94  { 50000, 50}, // SCORE_MIN_INCOME
95  { 100000, 100}, // SCORE_MAX_INCOME
96  { 40000, 400}, // SCORE_DELIVERED
97  { 8, 50}, // SCORE_CARGO
98  {10000000, 50}, // SCORE_MONEY
99  { 250000, 50}, // SCORE_LOAN
100  { 0, 0} // SCORE_TOTAL
101 };
102 
103 int64_t _score_part[MAX_COMPANIES][SCORE_END];
104 Economy _economy;
105 Prices _price;
106 static PriceMultipliers _price_base_multiplier;
107 
115 {
116  Owner owner = c->index;
117 
118  uint num = 0;
119 
120  for (const Station *st : Station::Iterate()) {
121  if (st->owner == owner) num += CountBits((uint8_t)st->facilities);
122  }
123 
124  Money value = num * _price[PR_STATION_VALUE] * 25;
125 
126  for (const Vehicle *v : Vehicle::Iterate()) {
127  if (v->owner != owner) continue;
128 
129  if (v->type == VEH_TRAIN ||
130  v->type == VEH_ROAD ||
131  (v->type == VEH_AIRCRAFT && Aircraft::From(v)->IsNormalAircraft()) ||
132  v->type == VEH_SHIP) {
133  value += v->value * 3 >> 1;
134  }
135  }
136 
137  return value;
138 }
139 
149 Money CalculateCompanyValue(const Company *c, bool including_loan)
150 {
152 
153  /* Add real money value */
154  if (including_loan) value -= c->current_loan;
155  value += c->money;
156 
157  return std::max<Money>(value, 1);
158 }
159 
177 {
179 
180  value += c->current_loan;
181  /* Negative balance is basically a loan. */
182  if (c->money < 0) {
183  value += -c->money;
184  }
185 
186  for (int quarter = 0; quarter < 4; quarter++) {
187  value += std::max<Money>(c->old_economy[quarter].income + c->old_economy[quarter].expenses, 0) * 2;
188  }
189 
190  return std::max<Money>(value, 1);
191 }
192 
202 {
203  Owner owner = c->index;
204  int score = 0;
205 
206  memset(_score_part[owner], 0, sizeof(_score_part[owner]));
207 
208  /* Count vehicles */
209  {
210  Money min_profit = 0;
211  bool min_profit_first = true;
212  uint num = 0;
213 
214  for (const Vehicle *v : Vehicle::Iterate()) {
215  if (v->owner != owner) continue;
216  if (IsCompanyBuildableVehicleType(v->type) && v->IsPrimaryVehicle()) {
217  if (v->profit_last_year > 0) num++; // For the vehicle score only count profitable vehicles
218  if (v->economy_age > VEHICLE_PROFIT_MIN_AGE) {
219  /* Find the vehicle with the lowest amount of profit */
220  if (min_profit_first || min_profit > v->profit_last_year) {
221  min_profit = v->profit_last_year;
222  min_profit_first = false;
223  }
224  }
225  }
226  }
227 
228  min_profit >>= 8; // remove the fract part
229 
230  _score_part[owner][SCORE_VEHICLES] = num;
231  /* Don't allow negative min_profit to show */
232  if (min_profit > 0) {
233  _score_part[owner][SCORE_MIN_PROFIT] = min_profit;
234  }
235  }
236 
237  /* Count stations */
238  {
239  uint num = 0;
240  for (const Station *st : Station::Iterate()) {
241  /* Only count stations that are actually serviced */
242  if (st->owner == owner && (st->time_since_load <= 20 || st->time_since_unload <= 20)) num += CountBits((uint8_t)st->facilities);
243  }
244  _score_part[owner][SCORE_STATIONS] = num;
245  }
246 
247  /* Generate statistics depending on recent income statistics */
248  {
249  int numec = std::min<uint>(c->num_valid_stat_ent, 12u);
250  if (numec != 0) {
251  const CompanyEconomyEntry *cee = c->old_economy;
252  Money min_income = cee->income + cee->expenses;
253  Money max_income = cee->income + cee->expenses;
254 
255  do {
256  min_income = std::min(min_income, cee->income + cee->expenses);
257  max_income = std::max(max_income, cee->income + cee->expenses);
258  } while (++cee, --numec);
259 
260  if (min_income > 0) {
261  _score_part[owner][SCORE_MIN_INCOME] = min_income;
262  }
263 
264  _score_part[owner][SCORE_MAX_INCOME] = max_income;
265  }
266  }
267 
268  /* Generate score depending on amount of transported cargo */
269  {
270  int numec = std::min<uint>(c->num_valid_stat_ent, 4u);
271  if (numec != 0) {
272  const CompanyEconomyEntry *cee = c->old_economy;
273  OverflowSafeInt64 total_delivered = 0;
274  do {
275  total_delivered += cee->delivered_cargo.GetSum<OverflowSafeInt64>();
276  } while (++cee, --numec);
277 
278  _score_part[owner][SCORE_DELIVERED] = total_delivered;
279  }
280  }
281 
282  /* Generate score for variety of cargo */
283  {
284  _score_part[owner][SCORE_CARGO] = c->old_economy->delivered_cargo.GetCount();
285  }
286 
287  /* Generate score for company's money */
288  {
289  if (c->money > 0) {
290  _score_part[owner][SCORE_MONEY] = c->money;
291  }
292  }
293 
294  /* Generate score for loan */
295  {
296  _score_part[owner][SCORE_LOAN] = _score_info[SCORE_LOAN].needed - c->current_loan;
297  }
298 
299  /* Now we calculate the score for each item.. */
300  {
301  int total_score = 0;
302  int s;
303  score = 0;
304  for (ScoreID i = SCORE_BEGIN; i < SCORE_END; i++) {
305  /* Skip the total */
306  if (i == SCORE_TOTAL) continue;
307  /* Check the score */
308  s = Clamp<int64_t>(_score_part[owner][i], 0, _score_info[i].needed) * _score_info[i].score / _score_info[i].needed;
309  score += s;
310  total_score += _score_info[i].score;
311  }
312 
313  _score_part[owner][SCORE_TOTAL] = score;
314 
315  /* We always want the score scaled to SCORE_MAX (1000) */
316  if (total_score != SCORE_MAX) score = score * SCORE_MAX / total_score;
317  }
318 
319  if (update) {
320  c->old_economy[0].performance_history = score;
321  UpdateCompanyHQ(c->location_of_HQ, score);
323  }
324 
326  return score;
327 }
328 
334 void ChangeOwnershipOfCompanyItems(Owner old_owner, Owner new_owner)
335 {
336  /* We need to set _current_company to old_owner before we try to move
337  * the client. This is needed as it needs to know whether "you" really
338  * are the current local company. */
339  Backup<CompanyID> cur_company(_current_company, old_owner);
340  /* In all cases, make spectators of clients connected to that company */
341  if (_networking) NetworkClientsToSpectators(old_owner);
342  if (old_owner == _local_company) {
343  /* Single player cheated to AI company.
344  * There are no spectators in singleplayer mode, so we must pick some other company. */
345  assert(!_networking);
346  Backup<CompanyID> cur_company2(_current_company);
347  for (const Company *c : Company::Iterate()) {
348  if (c->index != old_owner) {
349  SetLocalCompany(c->index);
350  break;
351  }
352  }
353  cur_company2.Restore();
354  assert(old_owner != _local_company);
355  }
356 
357  assert(old_owner != new_owner);
358 
359  /* Temporarily increase the company's money, to be sure that
360  * removing their property doesn't fail because of lack of money.
361  * Not too drastically though, because it could overflow */
362  if (new_owner == INVALID_OWNER) {
363  Company::Get(old_owner)->money = UINT64_MAX >> 2; // jackpot ;p
364  }
365 
366  for (Subsidy *s : Subsidy::Iterate()) {
367  if (s->awarded == old_owner) {
368  if (new_owner == INVALID_OWNER) {
369  delete s;
370  } else {
371  s->awarded = new_owner;
372  }
373  }
374  }
376 
377  /* Take care of rating and transport rights in towns */
378  for (Town *t : Town::Iterate()) {
379  /* If a company takes over, give the ratings to that company. */
380  if (new_owner != INVALID_OWNER) {
381  if (HasBit(t->have_ratings, old_owner)) {
382  if (HasBit(t->have_ratings, new_owner)) {
383  /* use max of the two ratings. */
384  t->ratings[new_owner] = std::max(t->ratings[new_owner], t->ratings[old_owner]);
385  } else {
386  SetBit(t->have_ratings, new_owner);
387  t->ratings[new_owner] = t->ratings[old_owner];
388  }
389  }
390  }
391 
392  /* Reset the ratings for the old owner */
393  t->ratings[old_owner] = RATING_INITIAL;
394  ClrBit(t->have_ratings, old_owner);
395 
396  /* Transfer exclusive rights */
397  if (t->exclusive_counter > 0 && t->exclusivity == old_owner) {
398  if (new_owner != INVALID_OWNER) {
399  t->exclusivity = new_owner;
400  } else {
401  t->exclusive_counter = 0;
402  t->exclusivity = INVALID_COMPANY;
403  }
404  }
405  }
406 
407  {
408  for (Vehicle *v : Vehicle::Iterate()) {
409  if (v->owner == old_owner && IsCompanyBuildableVehicleType(v->type)) {
410  if (new_owner == INVALID_OWNER) {
411  if (v->Previous() == nullptr) delete v;
412  } else {
413  if (v->IsEngineCountable()) GroupStatistics::CountEngine(v, -1);
414  if (v->IsPrimaryVehicle()) GroupStatistics::CountVehicle(v, -1);
415  }
416  }
417  }
418  }
419 
420  /* In all cases clear replace engine rules.
421  * Even if it was copied, it could interfere with new owner's rules */
423 
424  if (new_owner == INVALID_OWNER) {
425  RemoveAllGroupsForCompany(old_owner);
426  } else {
427  Company *c = Company::Get(old_owner);
428  for (Group *g : Group::Iterate()) {
429  if (g->owner == old_owner) {
430  g->owner = new_owner;
431  g->number = c->freegroups.UseID(c->freegroups.NextID());
432  }
433  }
434  }
435 
436  {
437  Company *new_company = new_owner == INVALID_OWNER ? nullptr : Company::Get(new_owner);
438 
439  /* Override company settings to new company defaults in case we need to convert them.
440  * This is required as the CmdChangeServiceInt doesn't copy the supplied value when it is non-custom
441  */
442  if (new_owner != INVALID_OWNER) {
443  Company *old_company = Company::Get(old_owner);
444 
446  old_company->settings.vehicle.servint_trains = new_company->settings.vehicle.servint_trains;
447  old_company->settings.vehicle.servint_roadveh = new_company->settings.vehicle.servint_roadveh;
448  old_company->settings.vehicle.servint_ships = new_company->settings.vehicle.servint_ships;
450  }
451 
452  for (Vehicle *v : Vehicle::Iterate()) {
453  if (v->owner == old_owner && IsCompanyBuildableVehicleType(v->type)) {
454  assert(new_owner != INVALID_OWNER);
455 
456  /* Correct default values of interval settings while maintaining custom set ones.
457  * This prevents invalid values on mismatching company defaults being accepted.
458  */
459  if (!v->ServiceIntervalIsCustom()) {
460  /* Technically, passing the interval is not needed as the command will query the default value itself.
461  * However, do not rely on that behaviour.
462  */
463  int interval = CompanyServiceInterval(new_company, v->type);
464  Command<CMD_CHANGE_SERVICE_INT>::Do(DC_EXEC | DC_BANKRUPT, v->index, interval, false, new_company->settings.vehicle.servint_ispercent);
465  }
466 
467  v->owner = new_owner;
468 
469  /* Owner changes, clear cache */
470  v->colourmap = PAL_NONE;
471  v->InvalidateNewGRFCache();
472 
473  if (v->IsEngineCountable()) {
475  }
476  if (v->IsPrimaryVehicle()) {
478  auto &unitidgen = new_company->freeunits[v->type];
479  v->unitnumber = unitidgen.UseID(unitidgen.NextID());
480  }
481 
482  /* Invalidate the vehicle's cargo payment "owner cache". */
483  if (v->cargo_payment != nullptr) v->cargo_payment->owner = nullptr;
484  }
485  }
486 
487  if (new_owner != INVALID_OWNER) GroupStatistics::UpdateAutoreplace(new_owner);
488  }
489 
490  /* Change ownership of tiles */
491  {
492  TileIndex tile = 0;
493  do {
494  ChangeTileOwner(tile, old_owner, new_owner);
495  } while (++tile != Map::Size());
496 
497  if (new_owner != INVALID_OWNER) {
498  /* Update all signals because there can be new segment that was owned by two companies
499  * and signals were not propagated
500  * Similar with crossings - it is needed to bar crossings that weren't before
501  * because of different owner of crossing and approaching train */
502  tile = 0;
503 
504  do {
505  if (IsTileType(tile, MP_RAILWAY) && IsTileOwner(tile, new_owner) && HasSignals(tile)) {
506  TrackBits tracks = GetTrackBits(tile);
507  do { // there may be two tracks with signals for TRACK_BIT_HORZ and TRACK_BIT_VERT
508  Track track = RemoveFirstTrack(&tracks);
509  if (HasSignalOnTrack(tile, track)) AddTrackToSignalBuffer(tile, track, new_owner);
510  } while (tracks != TRACK_BIT_NONE);
511  } else if (IsLevelCrossingTile(tile) && IsTileOwner(tile, new_owner)) {
512  UpdateLevelCrossing(tile);
513  }
514  } while (++tile != Map::Size());
515  }
516 
517  /* update signals in buffer */
519  }
520 
521  /* Add airport infrastructure count of the old company to the new one. */
522  if (new_owner != INVALID_OWNER) Company::Get(new_owner)->infrastructure.airport += Company::Get(old_owner)->infrastructure.airport;
523 
524  /* convert owner of stations (including deleted ones, but excluding buoys) */
525  for (Station *st : Station::Iterate()) {
526  if (st->owner == old_owner) {
527  /* if a company goes bankrupt, set owner to OWNER_NONE so the sign doesn't disappear immediately
528  * also, drawing station window would cause reading invalid company's colour */
529  st->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
530  }
531  }
532 
533  /* do the same for waypoints (we need to do this here so deleted waypoints are converted too) */
534  for (Waypoint *wp : Waypoint::Iterate()) {
535  if (wp->owner == old_owner) {
536  wp->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
537  }
538  }
539 
540  for (Sign *si : Sign::Iterate()) {
541  if (si->owner == old_owner) si->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
542  }
543 
544  /* Remove Game Script created Goals, CargoMonitors and Story pages. */
545  for (Goal *g : Goal::Iterate()) {
546  if (g->company == old_owner) delete g;
547  }
548 
549  ClearCargoPickupMonitoring(old_owner);
550  ClearCargoDeliveryMonitoring(old_owner);
551 
552  for (StoryPage *sp : StoryPage::Iterate()) {
553  if (sp->company == old_owner) delete sp;
554  }
555 
556  /* Change colour of existing windows */
557  if (new_owner != INVALID_OWNER) ChangeWindowOwner(old_owner, new_owner);
558 
559  cur_company.Restore();
560 
562 }
563 
569 {
570  /* If "Infinite money" setting is on, companies should not go bankrupt. */
572 
573  /* If the company has money again, it does not go bankrupt */
574  if (c->money - c->current_loan >= -c->GetMaxLoan()) {
575  int previous_months_of_bankruptcy = CeilDiv(c->months_of_bankruptcy, 3);
576  c->months_of_bankruptcy = 0;
577  c->bankrupt_asked = 0;
578  if (previous_months_of_bankruptcy != 0) CompanyAdminUpdate(c);
579  return;
580  }
581 
583 
584  switch (c->months_of_bankruptcy) {
585  /* All the boring cases (months) with a bad balance where no action is taken */
586  case 0:
587  case 1:
588  case 2:
589  case 3:
590 
591  case 5:
592  case 6:
593 
594  case 8:
595  case 9:
596  break;
597 
598  /* Warn about bankruptcy after 3 months */
599  case 4: {
601  SetDParam(0, STR_NEWS_COMPANY_IN_TROUBLE_TITLE);
602  SetDParam(1, STR_NEWS_COMPANY_IN_TROUBLE_DESCRIPTION);
603  SetDParamStr(2, cni->company_name);
604  AddCompanyNewsItem(STR_MESSAGE_NEWS_FORMAT, cni);
605  AI::BroadcastNewEvent(new ScriptEventCompanyInTrouble(c->index));
606  Game::NewEvent(new ScriptEventCompanyInTrouble(c->index));
607  break;
608  }
609 
610  /* Offer company for sale after 6 months */
611  case 7: {
612  /* Don't consider the loan */
613  Money val = CalculateCompanyValue(c, false);
614 
615  c->bankrupt_value = val;
616  c->bankrupt_asked = 1 << c->index; // Don't ask the owner
617  c->bankrupt_timeout = 0;
618 
619  /* The company assets should always have some value */
620  assert(c->bankrupt_value > 0);
621  break;
622  }
623 
624  /* Bankrupt company after 6 months (if the company has no value) or latest
625  * after 9 months (if it still had value after 6 months) */
626  default:
627  case 10: {
628  if (!_networking && _local_company == c->index) {
629  /* If we are in singleplayer mode, leave the company playing. Eg. there
630  * is no THE-END, otherwise mark the client as spectator to make sure
631  * they are no longer in control of this company. However... when you
632  * join another company (cheat) the "unowned" company can bankrupt. */
633  c->bankrupt_asked = MAX_UVALUE(CompanyMask);
634  break;
635  }
636 
637  /* Actually remove the company, but not when we're a network client.
638  * In case of network clients we will be getting a command from the
639  * server. It is done in this way as we are called from the
640  * StateGameLoop which can't change the current company, and thus
641  * updating the local company triggers an assert later on. In the
642  * case of a network game the command will be processed at a time
643  * that changing the current company is okay. In case of single
644  * player we are sure (the above check) that we are not the local
645  * company and thus we won't be moved. */
646  if (!_networking || _network_server) {
648  return;
649  }
650  break;
651  }
652  }
653 
655 }
656 
662 {
663  /* Check for bankruptcy each month */
664  for (Company *c : Company::Iterate()) {
666  }
667 
668  Backup<CompanyID> cur_company(_current_company);
669 
670  /* Pay Infrastructure Maintenance, if enabled */
672  /* Improved monthly infrastructure costs. */
673  for (const Company *c : Company::Iterate()) {
674  cur_company.Change(c->index);
675 
677  uint32_t rail_total = c->infrastructure.GetRailTotal();
678  for (RailType rt = RAILTYPE_BEGIN; rt < RAILTYPE_END; rt++) {
679  if (c->infrastructure.rail[rt] != 0) cost.AddCost(RailMaintenanceCost(rt, c->infrastructure.rail[rt], rail_total));
680  }
681  cost.AddCost(SignalMaintenanceCost(c->infrastructure.signal));
682  uint32_t road_total = c->infrastructure.GetRoadTotal();
683  uint32_t tram_total = c->infrastructure.GetTramTotal();
684  for (RoadType rt = ROADTYPE_BEGIN; rt < ROADTYPE_END; rt++) {
685  if (c->infrastructure.road[rt] != 0) cost.AddCost(RoadMaintenanceCost(rt, c->infrastructure.road[rt], RoadTypeIsRoad(rt) ? road_total : tram_total));
686  }
687  cost.AddCost(CanalMaintenanceCost(c->infrastructure.water));
688  cost.AddCost(StationMaintenanceCost(c->infrastructure.station));
689  cost.AddCost(AirportMaintenanceCost(c->index));
690 
692  }
693  }
694  cur_company.Restore();
695 
696  /* Only run the economic statics and update company stats every 3rd economy month (1st of quarter). */
697  if (!HasBit(1 << 0 | 1 << 3 | 1 << 6 | 1 << 9, TimerGameEconomy::month)) return;
698 
699  for (Company *c : Company::Iterate()) {
700  /* Drop the oldest history off the end */
701  std::copy_backward(c->old_economy, c->old_economy + MAX_HISTORY_QUARTERS - 1, c->old_economy + MAX_HISTORY_QUARTERS);
702  c->old_economy[0] = c->cur_economy;
703  c->cur_economy = {};
704 
705  if (c->num_valid_stat_ent != MAX_HISTORY_QUARTERS) c->num_valid_stat_ent++;
706 
708  if (c->block_preview != 0) c->block_preview--;
709  }
710 
717 }
718 
724 bool AddInflation(bool check_year)
725 {
726  /* The cargo payment inflation differs from the normal inflation, so the
727  * relative amount of money you make with a transport decreases slowly over
728  * the 170 years. After a few hundred years we reach a level in which the
729  * games will become unplayable as the maximum income will be less than
730  * the minimum running cost.
731  *
732  * Furthermore there are a lot of inflation related overflows all over the
733  * place. Solving them is hardly possible because inflation will always
734  * reach the overflow threshold some day. So we'll just perform the
735  * inflation mechanism during the first 170 years (the amount of years that
736  * one had in the original TTD) and stop doing the inflation after that
737  * because it only causes problems that can't be solved nicely and the
738  * inflation doesn't add anything after that either; it even makes playing
739  * it impossible due to the diverging cost and income rates.
740  */
741  if (check_year && (TimerGameCalendar::year < CalendarTime::ORIGINAL_BASE_YEAR || TimerGameCalendar::year >= CalendarTime::ORIGINAL_MAX_YEAR)) return true;
742 
743  if (_economy.inflation_prices == MAX_INFLATION || _economy.inflation_payment == MAX_INFLATION) return true;
744 
745  /* Approximation for (100 + infl_amount)% ** (1 / 12) - 100%
746  * scaled by 65536
747  * 12 -> months per year
748  * This is only a good approximation for small values
749  */
750  _economy.inflation_prices += (_economy.inflation_prices * _economy.infl_amount * 54) >> 16;
751  _economy.inflation_payment += (_economy.inflation_payment * _economy.infl_amount_pr * 54) >> 16;
752 
755 
756  return false;
757 }
758 
763 {
764  /* Setup maximum loan as a rounded down multiple of LOAN_INTERVAL. */
765  _economy.max_loan = ((uint64_t)_settings_game.difficulty.max_loan * _economy.inflation_prices >> 16) / LOAN_INTERVAL * LOAN_INTERVAL;
766 
767  /* Setup price bases */
768  for (Price i = PR_BEGIN; i < PR_END; i++) {
769  Money price = _price_base_specs[i].start_price;
770 
771  /* Apply difficulty settings */
772  uint mod = 1;
773  switch (_price_base_specs[i].category) {
774  case PCAT_RUNNING:
776  break;
777 
778  case PCAT_CONSTRUCTION:
780  break;
781 
782  default: break;
783  }
784  switch (mod) {
785  case 0: price *= 6; break;
786  case 1: price *= 8; break; // normalised to 1 below
787  case 2: price *= 9; break;
788  default: NOT_REACHED();
789  }
790 
791  /* Apply inflation */
792  price = (int64_t)price * _economy.inflation_prices;
793 
794  /* Apply newgrf modifiers, remove fractional part of inflation, and normalise on medium difficulty. */
795  int shift = _price_base_multiplier[i] - 16 - 3;
796  if (shift >= 0) {
797  price <<= shift;
798  } else {
799  price >>= -shift;
800  }
801 
802  /* Make sure the price does not get reduced to zero.
803  * Zero breaks quite a few commands that use a zero
804  * cost to see whether something got changed or not
805  * and based on that cause an error. When the price
806  * is zero that fails even when things are done. */
807  if (price == 0) {
808  price = Clamp(_price_base_specs[i].start_price, -1, 1);
809  /* No base price should be zero, but be sure. */
810  assert(price != 0);
811  }
812  /* Store value */
813  _price[i] = price;
814  }
815 
816  /* Setup cargo payment */
817  for (CargoSpec *cs : CargoSpec::Iterate()) {
818  cs->current_payment = (cs->initial_payment * (int64_t)_economy.inflation_payment) >> 16;
819  }
820 
826 }
827 
829 static void CompaniesPayInterest()
830 {
831  Backup<CompanyID> cur_company(_current_company);
832  for (const Company *c : Company::Iterate()) {
833  cur_company.Change(c->index);
834 
835  /* Over a year the paid interest should be "loan * interest percentage",
836  * but... as that number is likely not dividable by 12 (pay each month),
837  * one needs to account for that in the monthly fee calculations.
838  *
839  * To easily calculate what one should pay "this" month, you calculate
840  * what (total) should have been paid up to this month and you subtract
841  * whatever has been paid in the previous months. This will mean one month
842  * it'll be a bit more and the other it'll be a bit less than the average
843  * monthly fee, but on average it will be exact.
844  *
845  * In order to prevent cheating or abuse (just not paying interest by not
846  * taking a loan) we make companies pay interest on negative cash as well,
847  * except if infinite money is enabled.
848  */
849  Money yearly_fee = c->current_loan * _economy.interest_rate / 100;
850  Money available_money = GetAvailableMoney(c->index);
851  if (available_money < 0) {
852  yearly_fee += -available_money * _economy.interest_rate / 100;
853  }
854  Money up_to_previous_month = yearly_fee * TimerGameEconomy::month / 12;
855  Money up_to_this_month = yearly_fee * (TimerGameEconomy::month + 1) / 12;
856 
857  SubtractMoneyFromCompany(CommandCost(EXPENSES_LOAN_INTEREST, up_to_this_month - up_to_previous_month));
858 
859  SubtractMoneyFromCompany(CommandCost(EXPENSES_OTHER, _price[PR_STATION_VALUE] >> 2));
860  }
861  cur_company.Restore();
862 }
863 
864 static void HandleEconomyFluctuations()
865 {
866  if (_settings_game.difficulty.economy != 0) {
867  /* When economy is Fluctuating, decrease counter */
868  _economy.fluct--;
869  } else if (EconomyIsInRecession()) {
870  /* When it's Steady and we are in recession, end it now */
871  _economy.fluct = -12;
872  } else {
873  /* No need to do anything else in other cases */
874  return;
875  }
876 
877  if (_economy.fluct == 0) {
878  _economy.fluct = -(int)GB(Random(), 0, 2);
879  AddNewsItem(STR_NEWS_BEGIN_OF_RECESSION, NT_ECONOMY, NF_NORMAL);
880  } else if (_economy.fluct == -12) {
881  _economy.fluct = GB(Random(), 0, 8) + 312;
882  AddNewsItem(STR_NEWS_END_OF_RECESSION, NT_ECONOMY, NF_NORMAL);
883  }
884 }
885 
886 
891 {
892  memset(_price_base_multiplier, 0, sizeof(_price_base_multiplier));
893 }
894 
902 void SetPriceBaseMultiplier(Price price, int factor)
903 {
904  assert(price < PR_END);
905  _price_base_multiplier[price] = Clamp(factor, MIN_PRICE_MODIFIER, MAX_PRICE_MODIFIER);
906 }
907 
912 void StartupIndustryDailyChanges(bool init_counter)
913 {
914  uint map_size = Map::LogX() + Map::LogY();
915  /* After getting map size, it needs to be scaled appropriately and divided by 31,
916  * which stands for the days in a month.
917  * Using just 31 will make it so that a monthly reset (based on the real number of days of that month)
918  * would not be needed.
919  * Since it is based on "fractional parts", the leftover days will not make much of a difference
920  * on the overall total number of changes performed */
921  _economy.industry_daily_increment = (1 << map_size) / 31;
922 
923  if (init_counter) {
924  /* A new game or a savegame from an older version will require the counter to be initialized */
925  _economy.industry_daily_change_counter = 0;
926  }
927 }
928 
929 void StartupEconomy()
930 {
933  _economy.infl_amount_pr = std::max(0, _settings_game.difficulty.initial_interest - 1);
934  _economy.fluct = GB(Random(), 0, 8) + 168;
935 
937  /* Apply inflation that happened before our game start year. */
939  for (int i = 0; i < months; i++) {
940  AddInflation(false);
941  }
942  }
943 
944  /* Set up prices */
945  RecomputePrices();
946 
947  StartupIndustryDailyChanges(true); // As we are starting a new game, initialize the counter too
948 
949 }
950 
955 {
956  _economy.inflation_prices = _economy.inflation_payment = 1 << 16;
959 }
960 
969 Money GetPrice(Price index, uint cost_factor, const GRFFile *grf_file, int shift)
970 {
971  if (index >= PR_END) return 0;
972 
973  Money cost = _price[index] * cost_factor;
974  if (grf_file != nullptr) shift += grf_file->price_base_multipliers[index];
975 
976  if (shift >= 0) {
977  cost <<= shift;
978  } else {
979  cost >>= -shift;
980  }
981 
982  return cost;
983 }
984 
985 Money GetTransportedGoodsIncome(uint num_pieces, uint dist, uint16_t transit_periods, CargoID cargo_type)
986 {
987  const CargoSpec *cs = CargoSpec::Get(cargo_type);
988  if (!cs->IsValid()) {
989  /* User changed newgrfs and some vehicle still carries some cargo which is no longer available. */
990  return 0;
991  }
992 
993  /* Use callback to calculate cargo profit, if available */
995  uint32_t var18 = ClampTo<uint16_t>(dist) | (ClampTo<uint8_t>(num_pieces) << 16) | (ClampTo<uint8_t>(transit_periods) << 24);
996  uint16_t callback = GetCargoCallback(CBID_CARGO_PROFIT_CALC, 0, var18, cs);
997  if (callback != CALLBACK_FAILED) {
998  int result = GB(callback, 0, 14);
999 
1000  /* Simulate a 15 bit signed value */
1001  if (HasBit(callback, 14)) result -= 0x4000;
1002 
1003  /* "The result should be a signed multiplier that gets multiplied
1004  * by the amount of cargo moved and the price factor, then gets
1005  * divided by 8192." */
1006  return result * num_pieces * cs->current_payment / 8192;
1007  }
1008  }
1009 
1010  static const int MIN_TIME_FACTOR = 31;
1011  static const int MAX_TIME_FACTOR = 255;
1012  static const int TIME_FACTOR_FRAC_BITS = 4;
1013  static const int TIME_FACTOR_FRAC = 1 << TIME_FACTOR_FRAC_BITS;
1014 
1015  const int periods1 = cs->transit_periods[0];
1016  const int periods2 = cs->transit_periods[1];
1017  const int periods_over_periods1 = std::max(transit_periods - periods1, 0);
1018  const int periods_over_periods2 = std::max(periods_over_periods1 - periods2, 0);
1019  int periods_over_max = MIN_TIME_FACTOR - MAX_TIME_FACTOR;
1020  if (periods2 > -periods_over_max) {
1021  periods_over_max += transit_periods - periods1;
1022  } else {
1023  periods_over_max += 2 * (transit_periods - periods1) - periods2;
1024  }
1025 
1026  /*
1027  * The time factor is calculated based on the time it took
1028  * (transit_periods) compared two cargo-depending values. The
1029  * range is divided into four parts:
1030  *
1031  * - constant for fast transits
1032  * - linear decreasing with time with a slope of -1 for medium transports
1033  * - linear decreasing with time with a slope of -2 for slow transports
1034  * - after hitting MIN_TIME_FACTOR, the time factor will be asymptotically decreased to a limit of 1 with a scaled 1/(x+1) function.
1035  *
1036  */
1037  if (periods_over_max > 0) {
1038  const int time_factor = std::max(2 * MIN_TIME_FACTOR * TIME_FACTOR_FRAC * TIME_FACTOR_FRAC / (periods_over_max + 2 * TIME_FACTOR_FRAC), 1); // MIN_TIME_FACTOR / (x/(2 * TIME_FACTOR_FRAC) + 1) + 1, expressed as fixed point with TIME_FACTOR_FRAC_BITS.
1039  return BigMulS(dist * time_factor * num_pieces, cs->current_payment, 21 + TIME_FACTOR_FRAC_BITS);
1040  } else {
1041  const int time_factor = std::max(MAX_TIME_FACTOR - periods_over_periods1 - periods_over_periods2, MIN_TIME_FACTOR);
1042  return BigMulS(dist * time_factor * num_pieces, cs->current_payment, 21);
1043  }
1044 }
1045 
1047 static SmallIndustryList _cargo_delivery_destinations;
1048 
1059 static uint DeliverGoodsToIndustry(const Station *st, CargoID cargo_type, uint num_pieces, IndustryID source, CompanyID company)
1060 {
1061  /* Find the nearest industrytile to the station sign inside the catchment area, whose industry accepts the cargo.
1062  * This fails in three cases:
1063  * 1) The station accepts the cargo because there are enough houses around it accepting the cargo.
1064  * 2) The industries in the catchment area temporarily reject the cargo, and the daily station loop has not yet updated station acceptance.
1065  * 3) The results of callbacks CBID_INDUSTRY_REFUSE_CARGO and CBID_INDTILE_CARGO_ACCEPTANCE are inconsistent. (documented behaviour)
1066  */
1067 
1068  uint accepted = 0;
1069 
1070  for (const auto &i : st->industries_near) {
1071  if (num_pieces == 0) break;
1072 
1073  Industry *ind = i.industry;
1074  if (ind->index == source) continue;
1075 
1076  auto it = ind->GetCargoAccepted(cargo_type);
1077  /* Check if matching cargo has been found */
1078  if (it == std::end(ind->accepted)) continue;
1079 
1080  /* Check if industry temporarily refuses acceptance */
1081  if (IndustryTemporarilyRefusesCargo(ind, cargo_type)) continue;
1082 
1083  if (ind->exclusive_supplier != INVALID_OWNER && ind->exclusive_supplier != st->owner) continue;
1084 
1085  /* Insert the industry into _cargo_delivery_destinations, if not yet contained */
1087 
1088  uint amount = std::min(num_pieces, 0xFFFFu - it->waiting);
1089  it->waiting += amount;
1090  it->last_accepted = TimerGameEconomy::date;
1091  num_pieces -= amount;
1092  accepted += amount;
1093 
1094  /* Update the cargo monitor. */
1095  AddCargoDelivery(cargo_type, company, amount, SourceType::Industry, source, st, ind->index);
1096  }
1097 
1098  return accepted;
1099 }
1100 
1114 static Money DeliverGoods(int num_pieces, CargoID cargo_type, StationID dest, uint distance, uint16_t periods_in_transit, Company *company, SourceType src_type, SourceID src)
1115 {
1116  assert(num_pieces > 0);
1117 
1118  Station *st = Station::Get(dest);
1119 
1120  /* Give the goods to the industry. */
1121  uint accepted_ind = DeliverGoodsToIndustry(st, cargo_type, num_pieces, src_type == SourceType::Industry ? src : INVALID_INDUSTRY, company->index);
1122 
1123  /* If this cargo type is always accepted, accept all */
1124  uint accepted_total = HasBit(st->always_accepted, cargo_type) ? num_pieces : accepted_ind;
1125 
1126  /* Update station statistics */
1127  if (accepted_total > 0) {
1131  }
1132 
1133  /* Update company statistics */
1134  company->cur_economy.delivered_cargo[cargo_type] += accepted_total;
1135 
1136  /* Increase town's counter for town effects */
1137  const CargoSpec *cs = CargoSpec::Get(cargo_type);
1138  st->town->received[cs->town_acceptance_effect].new_act += accepted_total;
1139 
1140  /* Determine profit */
1141  Money profit = GetTransportedGoodsIncome(accepted_total, distance, periods_in_transit, cargo_type);
1142 
1143  /* Update the cargo monitor. */
1144  AddCargoDelivery(cargo_type, company->index, accepted_total - accepted_ind, src_type, src, st);
1145 
1146  /* Modify profit if a subsidy is in effect */
1147  if (CheckSubsidised(cargo_type, company->index, src_type, src, st)) {
1149  case 0: profit += profit >> 1; break;
1150  case 1: profit *= 2; break;
1151  case 2: profit *= 3; break;
1152  default: profit *= 4; break;
1153  }
1154  }
1155 
1156  return profit;
1157 }
1158 
1165 {
1166  const IndustrySpec *indspec = GetIndustrySpec(i->type);
1167  uint16_t callback = indspec->callback_mask;
1168 
1169  i->was_cargo_delivered = true;
1170 
1172  if (HasBit(callback, CBM_IND_PRODUCTION_CARGO_ARRIVAL)) {
1174  } else {
1176  }
1177  } else {
1178  for (auto ita = std::begin(i->accepted); ita != std::end(i->accepted); ++ita) {
1179  if (ita->waiting == 0 || !IsValidCargoID(ita->cargo)) continue;
1180 
1181  for (auto itp = std::begin(i->produced); itp != std::end(i->produced); ++itp) {
1182  if (!IsValidCargoID(itp->cargo)) continue;
1183  itp->waiting = ClampTo<uint16_t>(itp->waiting + (ita->waiting * indspec->input_cargo_multiplier[ita - std::begin(i->accepted)][itp - std::begin(i->produced)] / 256));
1184  }
1185 
1186  ita->waiting = 0;
1187  }
1188  }
1189 
1191  StartStopIndustryTileAnimation(i, IAT_INDUSTRY_RECEIVED_CARGO);
1192 }
1193 
1199  current_station(front->last_station_visited),
1200  front(front)
1201 {
1202 }
1203 
1204 CargoPayment::~CargoPayment()
1205 {
1206  if (this->CleaningPool()) return;
1207 
1208  this->front->cargo_payment = nullptr;
1209 
1210  if (this->visual_profit == 0 && this->visual_transfer == 0) return;
1211 
1212  Backup<CompanyID> cur_company(_current_company, this->front->owner);
1213 
1214  SubtractMoneyFromCompany(CommandCost(this->front->GetExpenseType(true), -this->route_profit));
1215  this->front->profit_this_year += (this->visual_profit + this->visual_transfer) << 8;
1216 
1217  if (this->route_profit != 0 && IsLocalCompany() && !PlayVehicleSound(this->front, VSE_LOAD_UNLOAD)) {
1218  SndPlayVehicleFx(SND_14_CASHTILL, this->front);
1219  }
1220 
1221  if (this->visual_transfer != 0) {
1222  ShowFeederIncomeAnimation(this->front->x_pos, this->front->y_pos,
1223  this->front->z_pos, this->visual_transfer, -this->visual_profit);
1224  } else {
1225  ShowCostOrIncomeAnimation(this->front->x_pos, this->front->y_pos,
1226  this->front->z_pos, -this->visual_profit);
1227  }
1228 
1229  cur_company.Restore();
1230 }
1231 
1239 void CargoPayment::PayFinalDelivery(CargoID cargo, const CargoPacket *cp, uint count, TileIndex current_tile)
1240 {
1241  if (this->owner == nullptr) {
1242  this->owner = Company::Get(this->front->owner);
1243  }
1244 
1245  /* Handle end of route payment */
1246  Money profit = DeliverGoods(count, cargo, this->current_station, cp->GetDistance(current_tile), cp->GetPeriodsInTransit(), this->owner, cp->GetSourceType(), cp->GetSourceID());
1247  this->route_profit += profit;
1248 
1249  /* The vehicle's profit is whatever route profit there is minus feeder shares. */
1250  this->visual_profit += profit - cp->GetFeederShare(count);
1251 }
1252 
1261 Money CargoPayment::PayTransfer(CargoID cargo, const CargoPacket *cp, uint count, TileIndex current_tile)
1262 {
1263  /* Pay transfer vehicle the difference between the payment for the journey from
1264  * the source to the current point, and the sum of the previous transfer payments */
1265  Money profit = -cp->GetFeederShare(count) + GetTransportedGoodsIncome(
1266  count,
1267  cp->GetDistance(current_tile),
1268  cp->GetPeriodsInTransit(),
1269  cargo);
1270 
1271  profit = profit * _settings_game.economy.feeder_payment_share / 100;
1272 
1273  this->visual_transfer += profit; // accumulate transfer profits for whole vehicle
1274  return profit; // account for the (virtual) profit already made for the cargo packet
1275 }
1276 
1281 void PrepareUnload(Vehicle *front_v)
1282 {
1283  Station *curr_station = Station::Get(front_v->last_station_visited);
1284  curr_station->loading_vehicles.push_back(front_v);
1285 
1286  /* At this moment loading cannot be finished */
1288 
1289  /* Start unloading at the first possible moment */
1290  front_v->load_unload_ticks = 1;
1291 
1292  assert(front_v->cargo_payment == nullptr);
1293  /* One CargoPayment per vehicle and the vehicle limit equals the
1294  * limit in number of CargoPayments. Can't go wrong. */
1297  front_v->cargo_payment = new CargoPayment(front_v);
1298 
1299  StationIDStack next_station = front_v->GetNextStoppingStation();
1300  if (front_v->orders == nullptr || (front_v->current_order.GetUnloadType() & OUFB_NO_UNLOAD) == 0) {
1301  Station *st = Station::Get(front_v->last_station_visited);
1302  for (Vehicle *v = front_v; v != nullptr; v = v->Next()) {
1303  const GoodsEntry *ge = &st->goods[v->cargo_type];
1304  if (v->cargo_cap > 0 && v->cargo.TotalCount() > 0) {
1305  v->cargo.Stage(
1307  front_v->last_station_visited, next_station,
1308  front_v->current_order.GetUnloadType(), ge,
1309  v->cargo_type, front_v->cargo_payment,
1310  v->GetCargoTile());
1311  if (v->cargo.UnloadCount() > 0) SetBit(v->vehicle_flags, VF_CARGO_UNLOADING);
1312  }
1313  }
1314  }
1315 }
1316 
1323 static uint GetLoadAmount(Vehicle *v)
1324 {
1325  const Engine *e = v->GetEngine();
1326  uint load_amount = e->info.load_amount;
1327 
1328  /* The default loadamount for mail is 1/4 of the load amount for passengers */
1329  bool air_mail = v->type == VEH_AIRCRAFT && !Aircraft::From(v)->IsNormalAircraft();
1330  if (air_mail) load_amount = CeilDiv(load_amount, 4);
1331 
1333  uint16_t cb_load_amount = CALLBACK_FAILED;
1334  if (e->GetGRF() != nullptr && e->GetGRF()->grf_version >= 8) {
1335  /* Use callback 36 */
1336  cb_load_amount = GetVehicleProperty(v, PROP_VEHICLE_LOAD_AMOUNT, CALLBACK_FAILED);
1337  } else if (HasBit(e->info.callback_mask, CBM_VEHICLE_LOAD_AMOUNT)) {
1338  /* Use callback 12 */
1339  cb_load_amount = GetVehicleCallback(CBID_VEHICLE_LOAD_AMOUNT, 0, 0, v->engine_type, v);
1340  }
1341  if (cb_load_amount != CALLBACK_FAILED) {
1342  if (e->GetGRF()->grf_version < 8) cb_load_amount = GB(cb_load_amount, 0, 8);
1343  if (cb_load_amount >= 0x100) {
1345  } else if (cb_load_amount != 0) {
1346  load_amount = cb_load_amount;
1347  }
1348  }
1349  }
1350 
1351  /* Scale load amount the same as capacity */
1352  if (HasBit(e->info.misc_flags, EF_NO_DEFAULT_CARGO_MULTIPLIER) && !air_mail) load_amount = CeilDiv(load_amount * CargoSpec::Get(v->cargo_type)->multiplier, 0x100);
1353 
1354  /* Zero load amount breaks a lot of things. */
1355  return std::max(1u, load_amount);
1356 }
1357 
1367 template<class Taction>
1368 bool IterateVehicleParts(Vehicle *v, Taction action)
1369 {
1370  for (Vehicle *w = v; w != nullptr;
1371  w = w->HasArticulatedPart() ? w->GetNextArticulatedPart() : nullptr) {
1372  if (!action(w)) return false;
1373  if (w->type == VEH_TRAIN) {
1374  Train *train = Train::From(w);
1375  if (train->IsMultiheaded() && !action(train->other_multiheaded_part)) return false;
1376  }
1377  }
1378  if (v->type == VEH_AIRCRAFT && Aircraft::From(v)->IsNormalAircraft()) return action(v->Next());
1379  return true;
1380 }
1381 
1386 {
1392  bool operator()(const Vehicle *v)
1393  {
1394  return v->cargo.StoredCount() == 0;
1395  }
1396 };
1397 
1402 {
1404  CargoTypes &refit_mask;
1405 
1413 
1420  bool operator()(const Vehicle *v)
1421  {
1422  this->consist_capleft[v->cargo_type] -= v->cargo_cap - v->cargo.ReservedCount();
1423  this->refit_mask |= EngInfo(v->engine_type)->refit_mask;
1424  return true;
1425  }
1426 };
1427 
1432 {
1434  StationID next_hop;
1435 
1441  ReturnCargoAction(Station *st, StationID next_one) : st(st), next_hop(next_one) {}
1442 
1449  {
1450  v->cargo.Return(UINT_MAX, &this->st->goods[v->cargo_type].cargo, this->next_hop, v->GetCargoTile());
1451  return true;
1452  }
1453 };
1454 
1459 {
1463  bool do_reserve;
1464 
1474 
1482  {
1483  if (this->do_reserve) {
1484  this->st->goods[v->cargo_type].cargo.Reserve(v->cargo_cap - v->cargo.RemainingCount(),
1485  &v->cargo, this->next_station, v->GetCargoTile());
1486  }
1487  this->consist_capleft[v->cargo_type] += v->cargo_cap - v->cargo.RemainingCount();
1488  return true;
1489  }
1490 };
1491 
1500 static void HandleStationRefit(Vehicle *v, CargoArray &consist_capleft, Station *st, StationIDStack next_station, CargoID new_cid)
1501 {
1502  Vehicle *v_start = v->GetFirstEnginePart();
1503  if (!IterateVehicleParts(v_start, IsEmptyAction())) return;
1504 
1505  Backup<CompanyID> cur_company(_current_company, v->owner);
1506 
1507  CargoTypes refit_mask = v->GetEngine()->info.refit_mask;
1508 
1509  /* Remove old capacity from consist capacity and collect refit mask. */
1510  IterateVehicleParts(v_start, PrepareRefitAction(consist_capleft, refit_mask));
1511 
1512  bool is_auto_refit = new_cid == CARGO_AUTO_REFIT;
1513  if (is_auto_refit) {
1514  /* Get a refittable cargo type with waiting cargo for next_station or INVALID_STATION. */
1515  new_cid = v_start->cargo_type;
1516  for (CargoID cid : SetCargoBitIterator(refit_mask)) {
1517  if (st->goods[cid].cargo.HasCargoFor(next_station)) {
1518  /* Try to find out if auto-refitting would succeed. In case the refit is allowed,
1519  * the returned refit capacity will be greater than zero. */
1520  auto [cc, refit_capacity, mail_capacity, cargo_capacities] = Command<CMD_REFIT_VEHICLE>::Do(DC_QUERY_COST, v_start->index, cid, 0xFF, true, false, 1); // Auto-refit and only this vehicle including artic parts.
1521  /* Try to balance different loadable cargoes between parts of the consist, so that
1522  * all of them can be loaded. Avoid a situation where all vehicles suddenly switch
1523  * to the first loadable cargo for which there is only one packet. If the capacities
1524  * are equal refit to the cargo of which most is available. This is important for
1525  * consists of only a single vehicle as those will generally have a consist_capleft
1526  * of 0 for all cargoes. */
1527  if (refit_capacity > 0 && (consist_capleft[cid] < consist_capleft[new_cid] ||
1528  (consist_capleft[cid] == consist_capleft[new_cid] &&
1529  st->goods[cid].cargo.AvailableCount() > st->goods[new_cid].cargo.AvailableCount()))) {
1530  new_cid = cid;
1531  }
1532  }
1533  }
1534  }
1535 
1536  /* Refit if given a valid cargo. */
1537  if (new_cid < NUM_CARGO && new_cid != v_start->cargo_type) {
1538  /* INVALID_STATION because in the DT_MANUAL case that's correct and in the DT_(A)SYMMETRIC
1539  * cases the next hop of the vehicle doesn't really tell us anything if the cargo had been
1540  * "via any station" before reserving. We rather produce some more "any station" cargo than
1541  * misrouting it. */
1542  IterateVehicleParts(v_start, ReturnCargoAction(st, INVALID_STATION));
1543  CommandCost cost = std::get<0>(Command<CMD_REFIT_VEHICLE>::Do(DC_EXEC, v_start->index, new_cid, 0xFF, true, false, 1)); // Auto-refit and only this vehicle including artic parts.
1544  if (cost.Succeeded()) v->First()->profit_this_year -= cost.GetCost() << 8;
1545  }
1546 
1547  /* Add new capacity to consist capacity and reserve cargo */
1548  IterateVehicleParts(v_start, FinalizeRefitAction(consist_capleft, st, next_station,
1549  is_auto_refit || (v->First()->current_order.GetLoadType() & OLFB_FULL_LOAD) != 0));
1550 
1551  cur_company.Restore();
1552 }
1553 
1560 static bool MayLoadUnderExclusiveRights(const Station *st, const Vehicle *v)
1561 {
1562  return st->owner != OWNER_NONE || st->town->exclusive_counter == 0 || st->town->exclusivity == v->owner;
1563 }
1564 
1566  Station *st;
1567  StationIDStack *next_station;
1568 
1569  ReserveCargoAction(Station *st, StationIDStack *next_station) :
1570  st(st), next_station(next_station) {}
1571 
1572  bool operator()(Vehicle *v)
1573  {
1574  if (v->cargo_cap > v->cargo.RemainingCount() && MayLoadUnderExclusiveRights(st, v)) {
1576  &v->cargo, *next_station, v->GetCargoTile());
1577  }
1578 
1579  return true;
1580  }
1581 
1582 };
1583 
1592 static void ReserveConsist(Station *st, Vehicle *u, CargoArray *consist_capleft, StationIDStack *next_station)
1593 {
1594  /* If there is a cargo payment not all vehicles of the consist have tried to do the refit.
1595  * In that case, only reserve if it's a fixed refit and the equivalent of "articulated chain"
1596  * a vehicle belongs to already has the right cargo. */
1597  bool must_reserve = !u->current_order.IsRefit() || u->cargo_payment == nullptr;
1598  for (Vehicle *v = u; v != nullptr; v = v->Next()) {
1599  assert(v->cargo_cap >= v->cargo.RemainingCount());
1600 
1601  /* Exclude various ways in which the vehicle might not be the head of an equivalent of
1602  * "articulated chain". Also don't do the reservation if the vehicle is going to refit
1603  * to a different cargo and hasn't tried to do so, yet. */
1604  if (!v->IsArticulatedPart() &&
1605  (v->type != VEH_TRAIN || !Train::From(v)->IsRearDualheaded()) &&
1606  (v->type != VEH_AIRCRAFT || Aircraft::From(v)->IsNormalAircraft()) &&
1607  (must_reserve || u->current_order.GetRefitCargo() == v->cargo_type)) {
1608  IterateVehicleParts(v, ReserveCargoAction(st, next_station));
1609  }
1610  if (consist_capleft == nullptr || v->cargo_cap == 0) continue;
1611  (*consist_capleft)[v->cargo_type] += v->cargo_cap - v->cargo.RemainingCount();
1612  }
1613 }
1614 
1622 static void UpdateLoadUnloadTicks(Vehicle *front, const Station *st, int ticks)
1623 {
1625  /* Each platform tile is worth 2 rail vehicles. */
1626  int overhang = front->GetGroundVehicleCache()->cached_total_length - st->GetPlatformLength(front->tile) * TILE_SIZE;
1627  if (overhang > 0) {
1628  ticks <<= 1;
1629  ticks += (overhang * ticks) / 8;
1630  }
1631  }
1632  /* Always wait at least 1, otherwise we'll wait 'infinitively' long. */
1633  front->load_unload_ticks = std::max(1, ticks);
1634 }
1635 
1640 static void LoadUnloadVehicle(Vehicle *front)
1641 {
1642  assert(front->current_order.IsType(OT_LOADING));
1643 
1644  StationID last_visited = front->last_station_visited;
1645  Station *st = Station::Get(last_visited);
1646 
1647  StationIDStack next_station = front->GetNextStoppingStation();
1648  bool use_autorefit = front->current_order.IsRefit() && front->current_order.GetRefitCargo() == CARGO_AUTO_REFIT;
1649  CargoArray consist_capleft{};
1650  if (_settings_game.order.improved_load && use_autorefit ?
1651  front->cargo_payment == nullptr : (front->current_order.GetLoadType() & OLFB_FULL_LOAD) != 0) {
1652  ReserveConsist(st, front,
1653  (use_autorefit && front->load_unload_ticks != 0) ? &consist_capleft : nullptr,
1654  &next_station);
1655  }
1656 
1657  /* We have not waited enough time till the next round of loading/unloading */
1658  if (front->load_unload_ticks != 0) return;
1659 
1660  if (front->type == VEH_TRAIN && (!IsTileType(front->tile, MP_STATION) || GetStationIndex(front->tile) != st->index)) {
1661  /* The train reversed in the station. Take the "easy" way
1662  * out and let the train just leave as it always did. */
1664  front->load_unload_ticks = 1;
1665  return;
1666  }
1667 
1668  int new_load_unload_ticks = 0;
1669  bool dirty_vehicle = false;
1670  bool dirty_station = false;
1671 
1672  bool completely_emptied = true;
1673  bool anything_unloaded = false;
1674  bool anything_loaded = false;
1675  CargoTypes full_load_amount = 0;
1676  CargoTypes cargo_not_full = 0;
1677  CargoTypes cargo_full = 0;
1678  CargoTypes reservation_left = 0;
1679 
1680  front->cur_speed = 0;
1681 
1682  CargoPayment *payment = front->cargo_payment;
1683 
1684  uint artic_part = 0; // Articulated part we are currently trying to load. (not counting parts without capacity)
1685  for (Vehicle *v = front; v != nullptr; v = v->Next()) {
1686  if (v == front || !v->Previous()->HasArticulatedPart()) artic_part = 0;
1687  if (v->cargo_cap == 0) continue;
1688  artic_part++;
1689 
1690  GoodsEntry *ge = &st->goods[v->cargo_type];
1691 
1692  if (HasBit(v->vehicle_flags, VF_CARGO_UNLOADING) && (front->current_order.GetUnloadType() & OUFB_NO_UNLOAD) == 0) {
1693  uint cargo_count = v->cargo.UnloadCount();
1694  uint amount_unloaded = _settings_game.order.gradual_loading ? std::min(cargo_count, GetLoadAmount(v)) : cargo_count;
1695  bool remaining = false; // Are there cargo entities in this vehicle that can still be unloaded here?
1696 
1697  if (!HasBit(ge->status, GoodsEntry::GES_ACCEPTANCE) && v->cargo.ActionCount(VehicleCargoList::MTA_DELIVER) > 0) {
1698  /* The station does not accept our goods anymore. */
1700  /* Transfer instead of delivering. */
1702  v->cargo.ActionCount(VehicleCargoList::MTA_DELIVER));
1703  } else {
1704  uint new_remaining = v->cargo.RemainingCount() + v->cargo.ActionCount(VehicleCargoList::MTA_DELIVER);
1705  if (v->cargo_cap < new_remaining) {
1706  /* Return some of the reserved cargo to not overload the vehicle. */
1707  v->cargo.Return(new_remaining - v->cargo_cap, &ge->cargo, INVALID_STATION, v->GetCargoTile());
1708  }
1709 
1710  /* Keep instead of delivering. This may lead to no cargo being unloaded, so ...*/
1712  v->cargo.ActionCount(VehicleCargoList::MTA_DELIVER));
1713 
1714  /* ... say we unloaded something, otherwise we'll think we didn't unload
1715  * something and we didn't load something, so we must be finished
1716  * at this station. Setting the unloaded means that we will get a
1717  * retry for loading in the next cycle. */
1718  anything_unloaded = true;
1719  }
1720  }
1721 
1722  if (v->cargo.ActionCount(VehicleCargoList::MTA_TRANSFER) > 0) {
1723  /* Mark the station dirty if we transfer, but not if we only deliver. */
1724  dirty_station = true;
1725 
1726  if (!ge->HasRating()) {
1727  /* Upon transferring cargo, make sure the station has a rating. Fake a pickup for the
1728  * first unload to prevent the cargo from quickly decaying after the initial drop. */
1729  ge->time_since_pickup = 0;
1731  }
1732  }
1733 
1734  assert(payment != nullptr);
1735  amount_unloaded = v->cargo.Unload(amount_unloaded, &ge->cargo, v->cargo_type, payment, v->GetCargoTile());
1736  remaining = v->cargo.UnloadCount() > 0;
1737  if (amount_unloaded > 0) {
1738  dirty_vehicle = true;
1739  anything_unloaded = true;
1740  new_load_unload_ticks += amount_unloaded;
1741 
1742  /* Deliver goods to the station */
1743  st->time_since_unload = 0;
1744  }
1745 
1746  if (_settings_game.order.gradual_loading && remaining) {
1747  completely_emptied = false;
1748  } else {
1749  /* We have finished unloading (cargo count == 0) */
1750  ClrBit(v->vehicle_flags, VF_CARGO_UNLOADING);
1751  }
1752 
1753  continue;
1754  }
1755 
1756  /* Do not pick up goods when we have no-load set or loading is stopped. */
1757  if (front->current_order.GetLoadType() & OLFB_NO_LOAD || HasBit(front->vehicle_flags, VF_STOP_LOADING)) continue;
1758 
1759  /* This order has a refit, if this is the first vehicle part carrying cargo and the whole vehicle is empty, try refitting. */
1760  if (front->current_order.IsRefit() && artic_part == 1) {
1761  HandleStationRefit(v, consist_capleft, st, next_station, front->current_order.GetRefitCargo());
1762  ge = &st->goods[v->cargo_type];
1763  }
1764 
1765  /* As we're loading here the following link can carry the full capacity of the vehicle. */
1766  v->refit_cap = v->cargo_cap;
1767 
1768  /* update stats */
1769  int t;
1770  switch (front->type) {
1771  case VEH_TRAIN:
1772  case VEH_SHIP:
1773  t = front->vcache.cached_max_speed;
1774  break;
1775 
1776  case VEH_ROAD:
1777  t = front->vcache.cached_max_speed / 2;
1778  break;
1779 
1780  case VEH_AIRCRAFT:
1781  t = Aircraft::From(front)->GetSpeedOldUnits(); // Convert to old units.
1782  break;
1783 
1784  default: NOT_REACHED();
1785  }
1786 
1787  /* if last speed is 0, we treat that as if no vehicle has ever visited the station. */
1788  ge->last_speed = ClampTo<uint8_t>(t);
1789  ge->last_age = ClampTo<uint8_t>(TimerGameCalendar::year - front->build_year);
1790 
1791  assert(v->cargo_cap >= v->cargo.StoredCount());
1792  /* Capacity available for loading more cargo. */
1793  uint cap_left = v->cargo_cap - v->cargo.StoredCount();
1794 
1795  if (cap_left > 0) {
1796  /* If vehicle can load cargo, reset time_since_pickup. */
1797  ge->time_since_pickup = 0;
1798 
1799  /* If there's goods waiting at the station, and the vehicle
1800  * has capacity for it, load it on the vehicle. */
1801  if ((v->cargo.ActionCount(VehicleCargoList::MTA_LOAD) > 0 || ge->cargo.AvailableCount() > 0) && MayLoadUnderExclusiveRights(st, v)) {
1802  if (v->cargo.StoredCount() == 0) TriggerVehicle(v, VEHICLE_TRIGGER_NEW_CARGO);
1803  if (_settings_game.order.gradual_loading) cap_left = std::min(cap_left, GetLoadAmount(v));
1804 
1805  uint loaded = ge->cargo.Load(cap_left, &v->cargo, next_station, v->GetCargoTile());
1806  if (v->cargo.ActionCount(VehicleCargoList::MTA_LOAD) > 0) {
1807  /* Remember if there are reservations left so that we don't stop
1808  * loading before they're loaded. */
1809  SetBit(reservation_left, v->cargo_type);
1810  }
1811 
1812  /* Store whether the maximum possible load amount was loaded or not.*/
1813  if (loaded == cap_left) {
1814  SetBit(full_load_amount, v->cargo_type);
1815  } else {
1816  ClrBit(full_load_amount, v->cargo_type);
1817  }
1818 
1819  /* TODO: Regarding this, when we do gradual loading, we
1820  * should first unload all vehicles and then start
1821  * loading them. Since this will cause
1822  * VEHICLE_TRIGGER_EMPTY to be called at the time when
1823  * the whole vehicle chain is really totally empty, the
1824  * completely_emptied assignment can then be safely
1825  * removed; that's how TTDPatch behaves too. --pasky */
1826  if (loaded > 0) {
1827  completely_emptied = false;
1828  anything_loaded = true;
1829 
1830  st->time_since_load = 0;
1831  st->last_vehicle_type = v->type;
1832 
1833  if (ge->cargo.TotalCount() == 0) {
1834  TriggerStationRandomisation(st, st->xy, SRT_CARGO_TAKEN, v->cargo_type);
1835  TriggerStationAnimation(st, st->xy, SAT_CARGO_TAKEN, v->cargo_type);
1836  AirportAnimationTrigger(st, AAT_STATION_CARGO_TAKEN, v->cargo_type);
1837  TriggerRoadStopRandomisation(st, st->xy, RSRT_CARGO_TAKEN, v->cargo_type);
1838  TriggerRoadStopAnimation(st, st->xy, SAT_CARGO_TAKEN, v->cargo_type);
1839  }
1840 
1841  new_load_unload_ticks += loaded;
1842 
1843  dirty_vehicle = dirty_station = true;
1844  }
1845  }
1846  }
1847 
1848  if (v->cargo.StoredCount() >= v->cargo_cap) {
1849  SetBit(cargo_full, v->cargo_type);
1850  } else {
1851  SetBit(cargo_not_full, v->cargo_type);
1852  }
1853  }
1854 
1855  if (anything_loaded || anything_unloaded) {
1856  if (front->type == VEH_TRAIN) {
1858  TriggerStationAnimation(st, front->tile, SAT_TRAIN_LOADS);
1859  } else if (front->type == VEH_ROAD) {
1861  TriggerRoadStopAnimation(st, front->tile, SAT_TRAIN_LOADS);
1862  }
1863  }
1864 
1865  /* Only set completely_emptied, if we just unloaded all remaining cargo */
1866  completely_emptied &= anything_unloaded;
1867 
1868  if (!anything_unloaded) delete payment;
1869 
1871  if (anything_loaded || anything_unloaded) {
1873  /* The time it takes to load one 'slice' of cargo or passengers depends
1874  * on the vehicle type - the values here are those found in TTDPatch */
1875  const uint gradual_loading_wait_time[] = { 40, 20, 10, 20 };
1876 
1877  new_load_unload_ticks = gradual_loading_wait_time[front->type];
1878  }
1879  /* We loaded less cargo than possible for all cargo types and it's not full
1880  * load and we're not supposed to wait any longer: stop loading. */
1881  if (!anything_unloaded && full_load_amount == 0 && reservation_left == 0 && !(front->current_order.GetLoadType() & OLFB_FULL_LOAD) &&
1882  front->current_order_time >= std::max(front->current_order.GetTimetabledWait() - front->lateness_counter, 0)) {
1884  }
1885 
1886  UpdateLoadUnloadTicks(front, st, new_load_unload_ticks);
1887  } else {
1888  UpdateLoadUnloadTicks(front, st, 20); // We need the ticks for link refreshing.
1889  bool finished_loading = true;
1890  if (front->current_order.GetLoadType() & OLFB_FULL_LOAD) {
1891  if (front->current_order.GetLoadType() == OLF_FULL_LOAD_ANY) {
1892  /* if the aircraft carries passengers and is NOT full, then
1893  * continue loading, no matter how much mail is in */
1894  if ((front->type == VEH_AIRCRAFT && IsCargoInClass(front->cargo_type, CC_PASSENGERS) && front->cargo_cap > front->cargo.StoredCount()) ||
1895  (cargo_not_full != 0 && (cargo_full & ~cargo_not_full) == 0)) { // There are still non-full cargoes
1896  finished_loading = false;
1897  }
1898  } else if (cargo_not_full != 0) {
1899  finished_loading = false;
1900  }
1901 
1902  /* Refresh next hop stats if we're full loading to make the links
1903  * known to the distribution algorithm and allow cargo to be sent
1904  * along them. Otherwise the vehicle could wait for cargo
1905  * indefinitely if it hasn't visited the other links yet, or if the
1906  * links die while it's loading. */
1907  if (!finished_loading) LinkRefresher::Run(front, true, true);
1908  }
1909 
1910  SB(front->vehicle_flags, VF_LOADING_FINISHED, 1, finished_loading);
1911  }
1912 
1913  /* Calculate the loading indicator fill percent and display
1914  * In the Game Menu do not display indicators
1915  * If _settings_client.gui.loading_indicators == 2, show indicators (bool can be promoted to int as 0 or 1 - results in 2 > 0,1 )
1916  * if _settings_client.gui.loading_indicators == 1, _local_company must be the owner or must be a spectator to show ind., so 1 > 0
1917  * if _settings_client.gui.loading_indicators == 0, do not display indicators ... 0 is never greater than anything
1918  */
1919  if (_game_mode != GM_MENU && (_settings_client.gui.loading_indicators > (uint)(front->owner != _local_company && _local_company != COMPANY_SPECTATOR))) {
1920  StringID percent_up_down = STR_NULL;
1921  int percent = CalcPercentVehicleFilled(front, &percent_up_down);
1922  if (front->fill_percent_te_id == INVALID_TE_ID) {
1923  front->fill_percent_te_id = ShowFillingPercent(front->x_pos, front->y_pos, front->z_pos + 20, percent, percent_up_down);
1924  } else {
1925  UpdateFillingPercent(front->fill_percent_te_id, percent, percent_up_down);
1926  }
1927  }
1928 
1929  if (completely_emptied) {
1930  /* Make sure the vehicle is marked dirty, since we need to update the NewGRF
1931  * properties such as weight, power and TE whenever the trigger runs. */
1932  dirty_vehicle = true;
1933  TriggerVehicle(front, VEHICLE_TRIGGER_EMPTY);
1934  }
1935 
1936  if (dirty_vehicle) {
1939  front->MarkDirty();
1940  }
1941  if (dirty_station) {
1942  st->MarkTilesDirty(true);
1945  }
1946 }
1947 
1954 {
1955  /* No vehicle is here... */
1956  if (st->loading_vehicles.empty()) return;
1957 
1958  Vehicle *last_loading = nullptr;
1959 
1960  /* Check if anything will be loaded at all. Otherwise we don't need to reserve either. */
1961  for (Vehicle *v : st->loading_vehicles) {
1962  if ((v->vehstatus & (VS_STOPPED | VS_CRASHED))) continue;
1963 
1964  assert(v->load_unload_ticks != 0);
1965  if (--v->load_unload_ticks == 0) last_loading = v;
1966  }
1967 
1968  /* We only need to reserve and load/unload up to the last loading vehicle.
1969  * Anything else will be forgotten anyway after returning from this function.
1970  *
1971  * Especially this means we do _not_ need to reserve cargo for a single
1972  * consist in a station which is not allowed to load yet because its
1973  * load_unload_ticks is still not 0.
1974  */
1975  if (last_loading == nullptr) return;
1976 
1977  for (Vehicle *v : st->loading_vehicles) {
1978  if (!(v->vehstatus & (VS_STOPPED | VS_CRASHED))) LoadUnloadVehicle(v);
1979  if (v == last_loading) break;
1980  }
1981 
1982  /* Call the production machinery of industries */
1983  for (Industry *iid : _cargo_delivery_destinations) {
1985  }
1987 }
1988 
1992 static IntervalTimer<TimerGameCalendar> _calendar_inflation_monthly({TimerGameCalendar::MONTH, TimerGameCalendar::Priority::COMPANY}, [](auto)
1993 {
1995  AddInflation();
1996  RecomputePrices();
1997  }
1998 });
1999 
2003 static IntervalTimer<TimerGameEconomy> _economy_companies_monthly({ TimerGameEconomy::MONTH, TimerGameEconomy::Priority::COMPANY }, [](auto)
2004 {
2007  HandleEconomyFluctuations();
2008 });
2009 
2010 static void DoAcquireCompany(Company *c, bool hostile_takeover)
2011 {
2012  CompanyID ci = c->index;
2013 
2015 
2016  SetDParam(0, STR_NEWS_COMPANY_MERGER_TITLE);
2017  SetDParam(1, hostile_takeover ? STR_NEWS_MERGER_TAKEOVER_TITLE : STR_NEWS_COMPANY_MERGER_DESCRIPTION);
2018  SetDParamStr(2, cni->company_name);
2020  SetDParam(4, c->bankrupt_value);
2021  AddCompanyNewsItem(STR_MESSAGE_NEWS_FORMAT, cni);
2022  AI::BroadcastNewEvent(new ScriptEventCompanyMerger(ci, _current_company));
2023  Game::NewEvent(new ScriptEventCompanyMerger(ci, _current_company));
2024 
2026 
2027  if (c->is_ai) AI::Stop(c->index);
2028 
2029  CloseCompanyWindows(ci);
2034 
2035  delete c;
2036 }
2037 
2048 CommandCost CmdBuyCompany(DoCommandFlag flags, CompanyID target_company, bool hostile_takeover)
2049 {
2050  Company *c = Company::GetIfValid(target_company);
2051  if (c == nullptr) return CMD_ERROR;
2052 
2053  /* If you do a hostile takeover but the company went bankrupt, buy it via bankruptcy rules. */
2054  if (hostile_takeover && HasBit(c->bankrupt_asked, _current_company)) hostile_takeover = false;
2055 
2056  /* Disable takeovers when not asked */
2057  if (!hostile_takeover && !HasBit(c->bankrupt_asked, _current_company)) return CMD_ERROR;
2058 
2059  /* Only allow hostile takeover of AI companies and when in single player */
2060  if (hostile_takeover && !c->is_ai) return CMD_ERROR;
2061  if (hostile_takeover && _networking) return CMD_ERROR;
2062 
2063  /* Disable taking over the local company in singleplayer mode */
2064  if (!_networking && _local_company == c->index) return CMD_ERROR;
2065 
2066  /* Do not allow companies to take over themselves */
2067  if (target_company == _current_company) return CMD_ERROR;
2068 
2069  /* Do not allow takeover if the resulting company would have too many vehicles. */
2070  if (!CheckTakeoverVehicleLimit(_current_company, target_company)) return_cmd_error(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME);
2071 
2072  /* Get the cost here as the company is deleted in DoAcquireCompany.
2073  * For bankruptcy this amount is calculated when the offer was made;
2074  * for hostile takeover you pay the current price. */
2075  CommandCost cost(EXPENSES_OTHER, hostile_takeover ? CalculateHostileTakeoverValue(c) : c->bankrupt_value);
2076 
2077  if (flags & DC_EXEC) {
2078  DoAcquireCompany(c, hostile_takeover);
2079  }
2080  return cost;
2081 }
Base functions for all AIs.
Base for aircraft.
Functions related to autoreplacing.
void RemoveAllEngineReplacementForCompany(Company *c)
Remove all engine replacement settings for the given company.
Class for backupping variables and making sure they are restored later.
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T SB(T &x, const uint8_t s, const uint8_t n, const U d)
Set n bits in x starting at bit s to d.
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
constexpr uint CountBits(T value)
Counts the number of set bits in a variable.
constexpr static debug_inline uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
constexpr T ClrBit(T &x, const uint8_t y)
Clears a bit in a variable.
Types related to cargoes...
uint8_t CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:22
bool IsValidCargoID(CargoID t)
Test whether cargo type is not INVALID_CARGO.
Definition: cargo_type.h:107
uint16_t SourceID
Contains either industry ID, town ID or company ID (or INVALID_SOURCE)
Definition: cargo_type.h:143
SourceType
Types of cargo source and destination.
Definition: cargo_type.h:137
@ Industry
Source/destination is an industry.
static const CargoID CARGO_AUTO_REFIT
Automatically choose cargo type when doing auto refitting.
Definition: cargo_type.h:77
void ClearCargoDeliveryMonitoring(CompanyID company)
Clear all delivery cargo monitors.
void ClearCargoPickupMonitoring(CompanyID company)
Clear all pick-up cargo monitors.
void AddCargoDelivery(CargoID cargo_type, CompanyID company, uint32_t amount, SourceType src_type, SourceID src, const Station *st, IndustryID dest)
Cargo was delivered to its final destination, update the pickup and delivery maps.
Cargo transport monitoring declarations.
bool IsCargoInClass(CargoID c, CargoClass cc)
Does cargo c have cargo class cc?
Definition: cargotype.h:232
@ CC_PASSENGERS
Passengers.
Definition: cargotype.h:50
static void BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company=MAX_COMPANIES)
Broadcast a new event to all active AIs.
Definition: ai_core.cpp:263
static void Stop(CompanyID company)
Stop a company to be controlled by an AI.
Definition: ai_core.cpp:107
@ MTA_KEEP
Keep the cargo in the vehicle.
Definition: cargopacket.h:299
@ MTA_DELIVER
Deliver the cargo to some town or industry.
Definition: cargopacket.h:298
@ MTA_LOAD
Load the cargo from the station.
Definition: cargopacket.h:300
@ MTA_TRANSFER
Transfer the cargo to the station.
Definition: cargopacket.h:297
Common return value for all commands.
Definition: command_type.h:23
bool Succeeded() const
Did this command succeed?
Definition: command_type.h:162
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
Definition: command_type.h:63
Money GetCost() const
The costs as made up to this moment.
Definition: command_type.h:83
UnitID UseID(UnitID index)
Use a unit number.
Definition: vehicle.cpp:1863
UnitID NextID() const
Find first unused unit number.
Definition: vehicle.cpp:1848
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:146
static void Run(Vehicle *v, bool allow_merge=true, bool is_full_loading=false)
Refresh all links the given vehicle will visit.
Definition: refresh.cpp:26
Minimal stack that uses a pool to avoid pointers.
uint TotalCount() const
Returns total count of cargo at the station, including cargo which is already reserved for loading.
Definition: cargopacket.h:607
uint AvailableCount() const
Returns sum of cargo still available for loading at the sation.
Definition: cargopacket.h:588
uint Reserve(uint max_move, VehicleCargoList *dest, StationIDStack next, TileIndex current_tile)
Reserves cargo for loading onto the vehicle.
uint Load(uint max_move, VehicleCargoList *dest, StationIDStack next, TileIndex current_tile)
Loads cargo onto a vehicle.
bool HasCargoFor(StationIDStack next) const
Check for cargo headed for a specific station.
Definition: cargopacket.h:565
static Year year
Current year, starting at 0.
static constexpr TimerGame< struct Calendar >::Year ORIGINAL_MAX_YEAR
The maximum year of the original TTD.
static constexpr TimerGame< struct Calendar >::Year ORIGINAL_BASE_YEAR
The minimum starting year/base year of the original TTD.
static Date date
Current date in days (day counter).
static Month month
Current month (0..11).
uint Return(uint max_move, StationCargoList *dest, StationID next_station, TileIndex current_tile)
Returns reserved cargo to the station and removes it from the cache.
uint ReservedCount() const
Returns sum of reserved cargo.
Definition: cargopacket.h:452
uint RemainingCount() const
Returns the sum of cargo to be kept in the vehicle at the current station.
Definition: cargopacket.h:470
uint StoredCount() const
Returns sum of cargo on board the vehicle (ie not only reserved).
Definition: cargopacket.h:434
Functions related to commands.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition: command_func.h:28
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
Definition: command_func.h:38
DoCommandFlag
List of flags for a command.
Definition: command_type.h:374
@ DC_BANKRUPT
company bankrupts, skip money check, skip vehicle on tile check in some cases
Definition: command_type.h:382
@ DC_QUERY_COST
query cost only, don't build.
Definition: command_type.h:378
@ DC_EXEC
execute the given command
Definition: command_type.h:376
int CompanyServiceInterval(const Company *c, VehicleType type)
Get the service interval for the given company and vehicle type.
void CompanyAdminUpdate(const Company *company)
Called whenever company related information changes in order to notify admins.
void SubtractMoneyFromCompany(const CommandCost &cost)
Subtract money from the _current_company, if the company is valid.
Money GetAvailableMoney(CompanyID company)
Get the amount of money that a company has available, or INT64_MAX if there is no such valid company.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:52
bool CheckTakeoverVehicleLimit(CompanyID cbig, CompanyID csmall)
Can company cbig buy company csmall without exceeding vehicle limits?
void SetLocalCompany(CompanyID new_company)
Sets the local company and updates the settings that are set on a per-company basis to reflect the co...
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:53
Command definitions related to companies.
Functions related to companies.
bool IsLocalCompany()
Is the current company the local company?
Definition: company_func.h:47
GUI Functions related to companies.
void CloseCompanyWindows(CompanyID company)
Close all windows of a company.
Definition: window.cpp:1168
@ CCA_DELETE
Delete a company.
Definition: company_type.h:70
static const uint MAX_HISTORY_QUARTERS
The maximum number of quarters kept as performance's history.
Definition: company_type.h:43
Owner
Enum for all companies/owners.
Definition: company_type.h:18
@ INVALID_COMPANY
An invalid company.
Definition: company_type.h:30
@ INVALID_OWNER
An invalid owner.
Definition: company_type.h:29
@ COMPANY_SPECTATOR
The client is spectating.
Definition: company_type.h:35
@ OWNER_NONE
The tile has no ownership.
Definition: company_type.h:25
@ MAX_COMPANIES
Maximum number of companies.
Definition: company_type.h:23
@ CRR_BANKRUPT
The company went belly-up.
Definition: company_type.h:59
Some simple functions to help with accessing containers.
bool include(Container &container, typename Container::const_reference &item)
Helper function to append an item to a container if it is not already contained.
static bool MayLoadUnderExclusiveRights(const Station *st, const Vehicle *v)
Test whether a vehicle can load cargo at a station even if exclusive transport rights are present.
Definition: economy.cpp:1560
static Money DeliverGoods(int num_pieces, CargoID cargo_type, StationID dest, uint distance, uint16_t periods_in_transit, Company *company, SourceType src_type, SourceID src)
Delivers goods to industries/towns and calculates the payment.
Definition: economy.cpp:1114
static void UpdateLoadUnloadTicks(Vehicle *front, const Station *st, int ticks)
Update the vehicle's load_unload_ticks, the time it will wait until it tries to load or unload again.
Definition: economy.cpp:1622
static uint DeliverGoodsToIndustry(const Station *st, CargoID cargo_type, uint num_pieces, IndustryID source, CompanyID company)
Transfer goods from station to industry.
Definition: economy.cpp:1059
int UpdateCompanyRatingAndValue(Company *c, bool update)
if update is set to true, the economy is updated with this score (also the house is updated,...
Definition: economy.cpp:201
const ScoreInfo _score_info[]
Score info, values used for computing the detailed performance rating.
Definition: economy.cpp:90
void ChangeOwnershipOfCompanyItems(Owner old_owner, Owner new_owner)
Change the ownership of all the items of a company.
Definition: economy.cpp:334
static void CompaniesPayInterest()
Let all companies pay the monthly interest on their loan.
Definition: economy.cpp:829
void LoadUnloadStation(Station *st)
Load/unload the vehicles in this station according to the order they entered.
Definition: economy.cpp:1953
void RecomputePrices()
Computes all prices, payments and maximum loan.
Definition: economy.cpp:762
static void LoadUnloadVehicle(Vehicle *front)
Loads/unload the vehicle if possible.
Definition: economy.cpp:1640
Money CalculateHostileTakeoverValue(const Company *c)
Calculate what you have to pay to take over a company.
Definition: economy.cpp:176
static Money CalculateCompanyAssetValue(const Company *c)
Calculate the value of the assets of a company.
Definition: economy.cpp:114
static SmallIndustryList _cargo_delivery_destinations
The industries we've currently brought cargo to.
Definition: economy.cpp:1047
void PrepareUnload(Vehicle *front_v)
Prepare the vehicle to be unloaded.
Definition: economy.cpp:1281
static uint GetLoadAmount(Vehicle *v)
Gets the amount of cargo the given vehicle can load in the current tick.
Definition: economy.cpp:1323
static IntervalTimer< TimerGameCalendar > _calendar_inflation_monthly({TimerGameCalendar::MONTH, TimerGameCalendar::Priority::COMPANY}, [](auto) { if(_settings_game.economy.inflation) { AddInflation();RecomputePrices();} })
Every calendar month update of inflation.
static void ReserveConsist(Station *st, Vehicle *u, CargoArray *consist_capleft, StationIDStack *next_station)
Reserves cargo if the full load order and improved_load is set or if the current order allows autoref...
Definition: economy.cpp:1592
CommandCost CmdBuyCompany(DoCommandFlag flags, CompanyID target_company, bool hostile_takeover)
Buy up another company.
Definition: economy.cpp:2048
void SetPriceBaseMultiplier(Price price, int factor)
Change a price base by the given factor.
Definition: economy.cpp:902
Money GetPrice(Price index, uint cost_factor, const GRFFile *grf_file, int shift)
Determine a certain price.
Definition: economy.cpp:969
static void TriggerIndustryProduction(Industry *i)
Inform the industry about just delivered cargo DeliverGoodsToIndustry() silently incremented incoming...
Definition: economy.cpp:1164
static IntervalTimer< TimerGameEconomy > _economy_companies_monthly({ TimerGameEconomy::MONTH, TimerGameEconomy::Priority::COMPANY }, [](auto) { CompaniesGenStatistics();CompaniesPayInterest();HandleEconomyFluctuations();})
Every economy month update of company economic data, plus economy fluctuations.
bool IterateVehicleParts(Vehicle *v, Taction action)
Iterate the articulated parts of a vehicle, also considering the special cases of "normal" aircraft a...
Definition: economy.cpp:1368
static int32_t BigMulS(const int32_t a, const int32_t b, const uint8_t shift)
Multiply two integer values and shift the results to right.
Definition: economy.cpp:80
void InitializeEconomy()
Resets economy to initial values.
Definition: economy.cpp:954
static void CompanyCheckBankrupt(Company *c)
Check for bankruptcy of a company.
Definition: economy.cpp:568
void ResetPriceBaseMultipliers()
Reset changes to the price base multipliers.
Definition: economy.cpp:890
static void HandleStationRefit(Vehicle *v, CargoArray &consist_capleft, Station *st, StationIDStack next_station, CargoID new_cid)
Refit a vehicle in a station.
Definition: economy.cpp:1500
static void CompaniesGenStatistics()
Update the finances of all companies.
Definition: economy.cpp:661
bool AddInflation(bool check_year)
Add monthly inflation.
Definition: economy.cpp:724
Money CalculateCompanyValue(const Company *c, bool including_loan)
Calculate the value of the company.
Definition: economy.cpp:149
void StartupIndustryDailyChanges(bool init_counter)
Initialize the variables that will maintain the daily industry change system.
Definition: economy.cpp:912
Base classes related to the economy.
CargoPaymentPool _cargo_payment_pool
The actual pool to store cargo payments in.
Command definitions related to the economy.
bool EconomyIsInRecession()
Is the economy in recession?
Definition: economy_func.h:49
ScoreID
Score categories in the detailed performance rating.
Definition: economy_type.h:60
@ SCORE_END
How many scores are there..
Definition: economy_type.h:72
@ SCORE_MAX
The max score that can be in the performance history.
Definition: economy_type.h:74
@ SCORE_TOTAL
This must always be the last entry.
Definition: economy_type.h:71
static const int MIN_PRICE_MODIFIER
Maximum NewGRF price modifiers.
Definition: economy_type.h:236
@ EXPENSES_PROPERTY
Property costs.
Definition: economy_type.h:179
@ EXPENSES_OTHER
Other expenses.
Definition: economy_type.h:185
@ EXPENSES_LOAN_INTEREST
Interest payments over the loan.
Definition: economy_type.h:184
Money Prices[PR_END]
Prices of everything.
Definition: economy_type.h:168
Price
Enumeration of all base prices for use with Prices.
Definition: economy_type.h:89
static const int LOAN_INTERVAL
The "steps" in loan size, in British Pounds!
Definition: economy_type.h:215
static const uint64_t MAX_INFLATION
Maximum inflation (including fractional part) without causing overflows in int64_t price computations...
Definition: economy_type.h:229
@ PCAT_RUNNING
Price is affected by "vehicle running cost" difficulty setting.
Definition: economy_type.h:200
@ PCAT_CONSTRUCTION
Price is affected by "construction cost" difficulty setting.
Definition: economy_type.h:201
Base class for engines.
@ EF_NO_DEFAULT_CARGO_MULTIPLIER
Use the new capacity algorithm. The default cargotype of the vehicle does not affect capacity multipl...
Definition: engine_type.h:174
Base functions for all Games.
Goal base class.
Base class and functions for all vehicles that move through ground.
void MarkTilesDirty(bool cargo_change) const
Marks the tiles of the station as dirty.
Definition: station.cpp:243
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition: gfx.cpp:1529
virtual void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
Definition: vehicle_base.h:407
Base of all industries.
const IndustrySpec * GetIndustrySpec(IndustryType thistype)
Accessor for array _industry_specs.
void ChangeTileOwner(TileIndex tile, Owner old_owner, Owner new_owner)
Change the owner of a tile.
Definition: landscape.cpp:565
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:320
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:79
void ShowCostOrIncomeAnimation(int x, int y, int z, Money cost)
Display animated income or costs on the map.
Definition: misc_gui.cpp:570
void ShowFeederIncomeAnimation(int x, int y, int z, Money transfer, Money income)
Display animated feeder income.
Definition: misc_gui.cpp:594
void UpdateFillingPercent(TextEffectID te_id, uint8_t percent, StringID string)
Update vehicle loading indicators.
Definition: misc_gui.cpp:636
TextEffectID ShowFillingPercent(int x, int y, int z, uint8_t percent, StringID string)
Display vehicle loading indicators.
Definition: misc_gui.cpp:621
bool _networking
are we in networking mode?
Definition: network.cpp:65
bool _network_server
network-server is active
Definition: network.cpp:66
Basic functions/variables used all over the place.
void NetworkClientsToSpectators(CompanyID cid)
Move the clients of a company to the spectators.
Network functions used by other parts of OpenTTD.
@ INVALID_CLIENT_ID
Client is not part of anything.
Definition: network_type.h:50
NewGRF handling of airport tiles.
@ IAT_INDUSTRY_RECEIVED_CARGO
Trigger when cargo is received .
@ AAT_STATION_CARGO_TAKEN
Triggered when a cargo type is completely removed from the station (for all tiles at the same time).
@ SAT_TRAIN_LOADS
Trigger platform when train loads/unloads.
@ SAT_CARGO_TAKEN
Trigger station when cargo is completely taken.
@ CBM_IND_PRODUCTION_CARGO_ARRIVAL
call production callback when cargo arrives at the industry
@ CBM_IND_PRODUCTION_256_TICKS
call production callback every 256 ticks
@ CBID_CARGO_PROFIT_CALC
Called to calculate the income of delivered cargo.
@ CBID_VEHICLE_LOAD_AMOUNT
Determine the amount of cargo to load per unit of time when using gradual loading.
@ CBM_VEHICLE_LOAD_AMOUNT
Load amount.
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
@ CBM_CARGO_PROFIT_CALC
custom profit calculation
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.
uint16_t GetVehicleCallback(CallbackID callback, uint32_t param1, uint32_t param2, EngineID engine, const Vehicle *v)
Evaluate a newgrf callback for vehicles.
Functions for NewGRF engines.
bool IndustryTemporarilyRefusesCargo(Industry *ind, CargoID cargo_type)
Check whether an industry temporarily refuses to accept a certain cargo.
void IndustryProductionCallback(Industry *ind, int reason)
Get the industry production callback and apply it to the industry.
void TriggerIndustry(Industry *ind, IndustryTileTrigger trigger)
Trigger a random trigger for all industry tiles.
NewGRF handling of industry tiles.
@ INDUSTRY_TRIGGER_RECEIVED_CARGO
Cargo has been delivered.
@ PROP_VEHICLE_LOAD_AMOUNT
Loading speed.
NewGRF definitions and structures for road stops.
@ RSRT_CARGO_TAKEN
Trigger roadstop when cargo is completely taken.
@ RSRT_VEH_LOADS
Trigger roadstop when road vehicle loads.
void TriggerRoadStopRandomisation(Station *st, TileIndex tile, RoadStopRandomTrigger trigger, CargoID cargo_type=INVALID_CARGO)
Trigger road stop randomisation.
bool PlayVehicleSound(const Vehicle *v, VehicleSoundEvent event, bool force)
Checks whether a NewGRF wants to play a different vehicle sound effect.
Functions related to NewGRF provided sounds.
@ VSE_LOAD_UNLOAD
Whenever cargo payment is made for a vehicle.
Definition: newgrf_sound.h:27
void TriggerStationRandomisation(Station *st, TileIndex trigger_tile, StationRandomTrigger trigger, CargoID cargo_type)
Trigger station randomisation.
Header file for NewGRF stations.
@ SRT_TRAIN_LOADS
Trigger platform when train loads/unloads.
@ SRT_CARGO_TAKEN
Trigger station when cargo is completely taken.
Functions related to news.
void AddNewsItem(StringID string, NewsType type, NewsFlag flags, NewsReferenceType reftype1=NR_NONE, uint32_t ref1=UINT32_MAX, NewsReferenceType reftype2=NR_NONE, uint32_t ref2=UINT32_MAX, const NewsAllocatedData *data=nullptr)
Add a new newsitem to be shown.
Definition: news_gui.cpp:829
@ NT_ECONOMY
Economic changes (recession, industry up/dowm)
Definition: news_type.h:31
@ NF_NORMAL
Normal news item. (Newspaper with text only)
Definition: news_type.h:81
Functions related to objects.
void UpdateCompanyHQ(TileIndex tile, uint score)
Update the CompanyHQ to the state associated with the given score.
Definition: object_cmd.cpp:164
@ OLFB_FULL_LOAD
Full load all cargoes of the consist.
Definition: order_type.h:64
@ OLFB_NO_LOAD
Do not load anything.
Definition: order_type.h:66
@ OLF_FULL_LOAD_ANY
Full load a single cargo of the consist.
Definition: order_type.h:65
@ OUFB_TRANSFER
Transfer all cargo onto the platform.
Definition: order_type.h:55
@ OUFB_NO_UNLOAD
Totally no unloading will be done.
Definition: order_type.h:56
@ OUFB_UNLOAD
Force unloading all cargo onto the platform, possibly not getting paid.
Definition: order_type.h:54
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.
Definition: pool_func.hpp:237
Price Bases.
Money RailMaintenanceCost(RailType railtype, uint32_t num, uint32_t total_num)
Calculates the maintenance cost of a number of track bits.
Definition: rail.h:430
Money SignalMaintenanceCost(uint32_t num)
Calculates the maintenance cost of a number of signals.
Definition: rail.h:441
TrackBits GetTrackBits(Tile tile)
Gets the track bits of the given tile.
Definition: rail_map.h:136
bool HasSignalOnTrack(Tile tile, Track track)
Checks for the presence of signals (either way) on the given track on the given rail tile.
Definition: rail_map.h:413
bool HasSignals(Tile t)
Checks if a rail tile has signals.
Definition: rail_map.h:72
RailType
Enumeration for all possible railtypes.
Definition: rail_type.h:27
@ RAILTYPE_BEGIN
Used for iterations.
Definition: rail_type.h:28
@ RAILTYPE_END
Used for iterations.
Definition: rail_type.h:33
Definition of link refreshing utility.
Money RoadMaintenanceCost(RoadType roadtype, uint32_t num, uint32_t total_num)
Calculates the maintenance cost of a number of road bits.
Definition: road_func.h:125
void UpdateLevelCrossing(TileIndex tile, bool sound=true, bool force_bar=false)
Update a level crossing to barred or open (crossing may include multiple adjacent tiles).
Definition: train_cmd.cpp:1773
bool IsLevelCrossingTile(Tile t)
Return whether a tile is a level crossing tile.
Definition: road_map.h:95
RoadType
The different roadtypes we support.
Definition: road_type.h:25
@ ROADTYPE_END
Used for iterations.
Definition: road_type.h:29
@ ROADTYPE_BEGIN
Used for iterations.
Definition: road_type.h:26
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:57
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:56
void AddTrackToSignalBuffer(TileIndex tile, Track track, Owner owner)
Add track to signal update buffer.
Definition: signal.cpp:592
static SigSegState UpdateSignalsInBuffer(Owner owner)
Updates blocks in _globset buffer.
Definition: signal.cpp:482
Base class for signs.
Functions related to sound.
@ SND_14_CASHTILL
18 == 0x12 Income from cargo delivery
Definition: sound_type.h:57
Money AirportMaintenanceCost(Owner owner)
Calculates the maintenance cost of all airports of a company.
Definition: station.cpp:709
Base classes/functions for stations.
Money StationMaintenanceCost(uint32_t num)
Calculates the maintenance cost of a number of station tiles.
Definition: station_func.h:60
StationID GetStationIndex(Tile t)
Get StationID from a tile.
Definition: station_map.h:28
Definition of base types and functions in a cross-platform compatible way.
#define MAX_UVALUE(type)
The largest value that can be entered in a variable.
Definition: stdafx.h:343
StoryPage base class.
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings.cpp:104
void SetDParamStr(size_t n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
Definition: strings.cpp:357
Functions related to OTTD's strings.
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition: strings_type.h:16
bool IsNormalAircraft() const
Check if the aircraft type is a normal flying device; eg not a rotor or a shadow.
Definition: aircraft.h:121
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
void Change(const U &new_value)
Change the value of the variable.
Definition: backup_type.hpp:82
void Restore()
Restore the variable.
TimerGameTick::Ticks current_order_time
How many ticks have passed since this order started.
Definition: base_consist.h:21
TimerGameTick::Ticks lateness_counter
How many ticks late (or early if negative) this vehicle is.
Definition: base_consist.h:22
uint16_t vehicle_flags
Used for gradual loading and other miscellaneous things (.
Definition: base_consist.h:34
TileIndex xy
Base tile of the station.
Owner owner
The owner of this station.
Town * town
The town this station is associated with.
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:51
Class for storing amounts of cargo.
Definition: cargo_type.h:114
uint GetCount() const
Get the amount of cargos that have an amount.
Definition: cargo_type.h:129
const T GetSum() const
Get the sum of all cargo amounts.
Definition: cargo_type.h:120
Container for cargo from the same location and time.
Definition: cargopacket.h:40
SourceID GetSourceID() const
Gets the ID of the cargo's source.
Definition: cargopacket.h:209
Money GetFeederShare() const
Gets the amount of money already paid to earlier vehicles in the feeder chain.
Definition: cargopacket.h:168
uint GetDistance(TileIndex current_tile) const
Get the current distance the cargo has traveled.
Definition: cargopacket.h:229
uint16_t GetPeriodsInTransit() const
Gets the number of cargo aging periods this cargo has been in transit.
Definition: cargopacket.h:191
SourceType GetSourceType() const
Gets the type of the cargo's source.
Definition: cargopacket.h:200
Helper class to perform the cargo payment.
Definition: economy_base.h:24
CargoPayment()
Constructor for pool saveload.
Definition: economy_base.h:35
Company * owner
NOSAVE: The owner of the vehicle.
Definition: economy_base.h:27
Money PayTransfer(CargoID cargo, const CargoPacket *cp, uint count, TileIndex current_tile)
Handle payment for transfer of the given cargo packet.
Definition: economy.cpp:1261
StationID current_station
NOSAVE: The current station.
Definition: economy_base.h:26
void PayFinalDelivery(CargoID cargo, const CargoPacket *cp, uint count, TileIndex current_tile)
Handle payment for final delivery of the given cargo packet.
Definition: economy.cpp:1239
Vehicle * front
The front vehicle to do the payment of.
Definition: economy_base.h:29
Money visual_transfer
The transfer credits to be shown.
Definition: economy_base.h:32
Money visual_profit
The visual profit to show.
Definition: economy_base.h:31
Money route_profit
The amount of money to add/remove from the bank account.
Definition: economy_base.h:30
Specification of a cargo type.
Definition: cargotype.h:71
uint16_t multiplier
Capacity multiplier for vehicles. (8 fractional bits)
Definition: cargotype.h:77
static IterateWrapper Iterate(size_t from=0)
Returns an iterable ensemble of all valid CargoSpec.
Definition: cargotype.h:190
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo ID.
Definition: cargotype.h:134
uint8_t callback_mask
Bitmask of cargo callbacks that have to be called.
Definition: cargotype.h:86
TownAcceptanceEffect town_acceptance_effect
The effect that delivering this cargo type has on towns. Also affects destination of subsidies.
Definition: cargotype.h:83
bool IsValid() const
Tests for validity of this cargospec.
Definition: cargotype.h:115
GUISettings gui
settings related to the GUI
Statistics about the economy.
Definition: company_base.h:24
Money income
The amount of income.
Definition: company_base.h:25
Money expenses
The amount of expenses.
Definition: company_base.h:26
Money company_value
The value of the company.
Definition: company_base.h:29
CargoArray delivered_cargo
The amount of delivered cargo.
Definition: company_base.h:27
int32_t performance_history
Company score (scale 0-1000)
Definition: company_base.h:28
Data that needs to be stored for company news messages.
Definition: news_type.h:153
std::string company_name
The name of the company.
Definition: news_type.h:154
std::string other_company_name
The name of the company taking over this one.
Definition: news_type.h:156
TileIndex location_of_HQ
Northern tile of HQ; INVALID_TILE when there is none.
Definition: company_base.h:91
uint8_t months_of_bankruptcy
Number of months that the company is unable to pay its debts.
Definition: company_base.h:98
CompanyMask bankrupt_asked
which companies were asked about buying it?
Definition: company_base.h:99
int16_t bankrupt_timeout
If bigger than 0, amount of time to wait for an answer on an offer to buy this company.
Definition: company_base.h:100
CompanySettings settings
settings specific for each company
Definition: company_base.h:122
CompanyEconomyEntry old_economy[MAX_HISTORY_QUARTERS]
Economic data of the company of the last MAX_HISTORY_QUARTERS quarters.
Definition: company_base.h:116
bool is_ai
If true, the company is (also) controlled by the computer (a NoAI program).
Definition: company_base.h:112
Money current_loan
Amount of money borrowed from the bank.
Definition: company_base.h:84
CompanyEconomyEntry cur_economy
Economic data of the company of this quarter.
Definition: company_base.h:115
Money money
Money owned by the company.
Definition: company_base.h:82
uint8_t num_valid_stat_ent
Number of valid statistical entries in old_economy.
Definition: company_base.h:117
VehicleDefaultSettings vehicle
default settings for vehicles
Money GetMaxLoan() const
Calculate the max allowed loan for this company.
uint8_t initial_interest
amount of interest (to pay over the loan)
bool infinite_money
whether spending money despite negative balance is allowed
uint32_t max_loan
the maximum initial loan
uint8_t construction_cost
how expensive is building
uint8_t subsidy_multiplier
payment multiplier for subsidized deliveries
uint8_t vehicle_costs
amount of money spent on vehicle running cost
bool economy
how volatile is the economy
bool inflation
disable inflation
bool infrastructure_maintenance
enable monthly maintenance fee for owner infrastructure
uint8_t feeder_payment_share
percentage of leg payment to virtually pay in feeder systems
Data of the economy.
Definition: economy_type.h:43
uint64_t inflation_payment
Cumulated inflation of cargo payment since game start; 16 bit fractional part.
Definition: economy_type.h:52
uint8_t infl_amount
inflation amount
Definition: economy_type.h:47
uint64_t inflation_prices
Cumulated inflation of prices since game start; 16 bit fractional part.
Definition: economy_type.h:51
int16_t fluct
Economy fluctuation status.
Definition: economy_type.h:45
uint8_t infl_amount_pr
inflation rate for payment rates
Definition: economy_type.h:48
uint32_t industry_daily_change_counter
Bits 31-16 are number of industry to be performed, 15-0 are fractional collected daily.
Definition: economy_type.h:49
uint32_t industry_daily_increment
The value which will increment industry_daily_change_counter. Computed value. NOSAVE.
Definition: economy_type.h:50
Money max_loan
NOSAVE: Maximum possible loan.
Definition: economy_type.h:44
uint8_t interest_rate
Interest.
Definition: economy_type.h:46
uint8_t misc_flags
Miscellaneous flags.
Definition: engine_type.h:155
uint16_t callback_mask
Bitmask of vehicle callbacks that have to be called.
Definition: engine_type.h:156
uint32_t GetGRFID() const
Retrieve the GRF ID of the NewGRF the engine is tied to.
Definition: engine.cpp:157
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
Definition: engine_base.h:167
Action for finalizing a refit.
Definition: economy.cpp:1459
CargoArray & consist_capleft
Capacities left in the consist.
Definition: economy.cpp:1460
bool do_reserve
If the vehicle should reserve.
Definition: economy.cpp:1463
StationIDStack & next_station
Next hops to reserve cargo for.
Definition: economy.cpp:1462
bool operator()(Vehicle *v)
Reserve cargo from the station and update the remaining consist capacities with the vehicle's remaini...
Definition: economy.cpp:1481
Station * st
Station to reserve cargo from.
Definition: economy.cpp:1461
FinalizeRefitAction(CargoArray &consist_capleft, Station *st, StationIDStack &next_station, bool do_reserve)
Create a finalizing action.
Definition: economy.cpp:1472
Dynamic data of a loaded NewGRF.
Definition: newgrf.h:108
PriceMultipliers price_base_multipliers
Price base multipliers as set by the grf.
Definition: newgrf.h:150
uint8_t loading_indicators
show loading indicators
EconomySettings economy
settings to change the economy
DifficultySettings difficulty
settings related to the difficulty
OrderSettings order
settings related to orders
Struct about goals, current and completed.
Definition: goal_base.h:21
Stores station stats for a single cargo.
Definition: station_base.h:166
bool HasRating() const
Does this cargo have a rating at this station?
Definition: station_base.h:258
@ GES_ACCEPTANCE
Set when the station accepts the cargo currently for final deliveries.
Definition: station_base.h:173
@ GES_RATING
This indicates whether a cargo has a rating at the station.
Definition: station_base.h:183
@ GES_CURRENT_MONTH
Set when cargo was delivered for final delivery this month.
Definition: station_base.h:201
@ GES_EVER_ACCEPTED
Set when a vehicle ever delivered cargo to the station for final delivery.
Definition: station_base.h:189
@ GES_ACCEPTED_BIGTICK
Set when cargo was delivered for final delivery during the current STATION_ACCEPTANCE_TICKS interval.
Definition: station_base.h:207
uint8_t last_speed
Maximum speed (up to 255) of the last vehicle that tried to load this cargo.
Definition: station_base.h:237
uint8_t last_age
Age in years (up to 255) of the last vehicle that tried to load this cargo.
Definition: station_base.h:243
uint8_t time_since_pickup
Number of rating-intervals (up to 255) since the last vehicle tried to load this cargo.
Definition: station_base.h:224
StationCargoList cargo
The cargo packets of cargo waiting in this station.
Definition: station_base.h:210
uint8_t status
Status of this cargo, see GoodsEntryStatus.
Definition: station_base.h:217
uint16_t cached_total_length
Length of the whole vehicle (valid only for the first engine).
bool IsMultiheaded() const
Check if the vehicle is a multiheaded engine.
static void CountVehicle(const Vehicle *v, int delta)
Update num_vehicle when adding or removing a vehicle.
Definition: group_cmd.cpp:133
static void CountEngine(const Vehicle *v, int delta)
Update num_engines when adding/removing an engine.
Definition: group_cmd.cpp:158
static void UpdateAutoreplace(CompanyID company)
Update autoreplace_defined and autoreplace_finished of all statistics of a company.
Definition: group_cmd.cpp:221
Group data.
Definition: group.h:72
Defines the data structure for constructing industry.
Definition: industrytype.h:101
uint16_t callback_mask
Bitmask of industry callbacks that have to be called.
Definition: industrytype.h:130
uint16_t input_cargo_multiplier[INDUSTRY_NUM_INPUTS][INDUSTRY_NUM_OUTPUTS]
Input cargo multipliers (multiply amount of incoming cargo for the produced cargoes)
Definition: industrytype.h:116
Defines the internal data of a functional industry.
Definition: industry.h:66
IndustryType type
type of industry.
Definition: industry.h:102
Owner exclusive_supplier
Which company has exclusive rights to deliver cargo (INVALID_OWNER = anyone)
Definition: industry.h:117
AcceptedCargoes::iterator GetCargoAccepted(CargoID cargo)
Get accepted cargo slot for a specific cargo type.
Definition: industry.h:189
ProducedCargoes produced
produced cargo slots
Definition: industry.h:97
AcceptedCargoes accepted
accepted cargo slots
Definition: industry.h:98
uint8_t was_cargo_delivered
flag that indicate this has been the closest industry chosen for cargo delivery by a station....
Definition: industry.h:106
Action to check if a vehicle has no stored cargo.
Definition: economy.cpp:1386
bool operator()(const Vehicle *v)
Checks if the vehicle has stored cargo.
Definition: economy.cpp:1392
static debug_inline uint LogX()
Logarithm of the map size along the X side.
Definition: map_func.h:251
static uint LogY()
Logarithm of the map size along the y side.
Definition: map_func.h:261
static debug_inline uint Size()
Get the size of the map.
Definition: map_func.h:288
bool station_length_loading_penalty
make trains longer than the station load more slowly
bool improved_load
improved loading algorithm
bool gradual_loading
load vehicles gradually
CargoID GetRefitCargo() const
Get the cargo to to refit to.
Definition: order_base.h:131
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition: order_base.h:70
OrderLoadFlags GetLoadType() const
How must the consist be loaded?
Definition: order_base.h:136
uint16_t GetTimetabledWait() const
Get the time in ticks a vehicle should wait at the destination or 0 if it's not timetabled.
Definition: order_base.h:188
OrderUnloadFlags GetUnloadType() const
How must the consist be unloaded?
Definition: order_base.h:138
bool IsRefit() const
Is this order a refit order.
Definition: order_base.h:117
Tindex index
Index of this pool item.
Definition: pool_type.hpp:238
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:339
static bool CleaningPool()
Returns current state of pool cleaning - yes or no.
Definition: pool_type.hpp:318
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:309
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:350
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:388
Base class for all pools.
Definition: pool_type.hpp:80
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
Definition: pool_type.hpp:84
Refit preparation action.
Definition: economy.cpp:1402
CargoTypes & refit_mask
Bitmask of possible refit cargoes.
Definition: economy.cpp:1404
PrepareRefitAction(CargoArray &consist_capleft, CargoTypes &refit_mask)
Create a refit preparation action.
Definition: economy.cpp:1411
CargoArray & consist_capleft
Capacities left in the consist.
Definition: economy.cpp:1403
bool operator()(const Vehicle *v)
Prepares for refitting of a vehicle, subtracting its free capacity from consist_capleft and adding th...
Definition: economy.cpp:1420
Money start_price
Default value at game start, before adding multipliers.
Definition: economy_type.h:208
Action for returning reserved cargo.
Definition: economy.cpp:1432
Station * st
Station to give the returned cargo to.
Definition: economy.cpp:1433
bool operator()(Vehicle *v)
Return all reserved cargo from a vehicle.
Definition: economy.cpp:1448
ReturnCargoAction(Station *st, StationID next_one)
Construct a cargo return action.
Definition: economy.cpp:1441
StationID next_hop
Next hop the cargo should be assigned to.
Definition: economy.cpp:1434
Data structure for storing how the score is computed for a single score id.
Definition: economy_type.h:80
int needed
How much you need to get the perfect score.
Definition: economy_type.h:81
int score
How much score it will give.
Definition: economy_type.h:82
Iterable ensemble of each set bit in a value.
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
static Station * Get(size_t index)
Gets station with given index.
static Aircraft * From(Vehicle *v)
Converts a Vehicle to SpecializedVehicle with type checking.
Station data structure.
Definition: station_base.h:439
uint GetPlatformLength(TileIndex tile, DiagDirection dir) const override
Determines the REMAINING length of a platform, starting at (and including) the given tile.
Definition: station.cpp:285
IndustryList industries_near
Cached list of industries near the station that can accept cargo,.
Definition: station_base.h:471
CargoTypes always_accepted
Bitmask of always accepted cargo types (by houses, HQs, industry tiles when industry doesn't accept c...
Definition: station_base.h:469
GoodsEntry goods[NUM_CARGO]
Goods at this station.
Definition: station_base.h:468
Struct about stories, current and completed.
Definition: story_base.h:164
Struct about subsidies, offered and awarded.
Definition: subsidy_base.h:22
Town data structure.
Definition: town.h:54
TransportedCargoStat< uint16_t > received[NUM_TAE]
Cargo statistics about received cargotypes.
Definition: town.h:80
CompanyID exclusivity
which company has exclusivity
Definition: town.h:75
uint8_t exclusive_counter
months till the exclusivity expires
Definition: town.h:76
'Train' is either a loco or a wagon.
Definition: train.h:89
Tstorage new_act
Actually transported this month.
Definition: town_type.h:117
uint16_t cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
Definition: vehicle_base.h:126
uint16_t servint_aircraft
service interval for aircraft
uint16_t servint_roadveh
service interval for road vehicles
uint16_t servint_ships
service interval for ships
bool servint_ispercent
service intervals are in percents
uint16_t servint_trains
service interval for trains
Vehicle data structure.
Definition: vehicle_base.h:244
CargoPayment * cargo_payment
The cargo payment we're currently in.
Definition: vehicle_base.h:277
EngineID engine_type
The type of engine used for this vehicle.
Definition: vehicle_base.h:323
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
Definition: vehicle_base.h:639
int32_t z_pos
z coordinate.
Definition: vehicle_base.h:306
StationIDStack GetNextStoppingStation() const
Get the next station the vehicle will stop at.
Definition: vehicle_base.h:750
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition: vehicle.cpp:747
VehicleCargoList cargo
The cargo this vehicle is carrying.
Definition: vehicle_base.h:341
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:645
uint16_t cargo_cap
total capacity
Definition: vehicle_base.h:344
Money profit_this_year
Profit this year << 8, low 8 bits are fract.
Definition: vehicle_base.h:273
bool HasArticulatedPart() const
Check if an engine has an articulated part.
Definition: vehicle_base.h:963
Vehicle * GetFirstEnginePart()
Get the first part of an articulated engine.
Definition: vehicle_base.h:983
Vehicle * Next() const
Get the next vehicle of this vehicle.
Definition: vehicle_base.h:632
Order current_order
The current order (+ status, like: loading)
Definition: vehicle_base.h:356
CargoID cargo_type
type of cargo this vehicle is carrying
Definition: vehicle_base.h:342
int32_t y_pos
y coordinate.
Definition: vehicle_base.h:305
int32_t x_pos
x coordinate.
Definition: vehicle_base.h:304
OrderList * orders
Pointer to the order list for this vehicle.
Definition: vehicle_base.h:359
uint8_t vehstatus
Status.
Definition: vehicle_base.h:354
VehicleCache vcache
Cache of often used vehicle values.
Definition: vehicle_base.h:364
GroundVehicleCache * GetGroundVehicleCache()
Access the ground vehicle cache of the vehicle.
Definition: vehicle.cpp:3155
virtual ExpensesType GetExpenseType([[maybe_unused]] bool income) const
Sets the expense type associated to this vehicle type.
Definition: vehicle_base.h:466
uint16_t load_unload_ticks
Ticks to wait before starting next cycle.
Definition: vehicle_base.h:352
uint16_t cur_speed
current speed
Definition: vehicle_base.h:328
TextEffectID fill_percent_te_id
a text-effect id to a loading indicator object
Definition: vehicle_base.h:325
TileIndex tile
Current tile index.
Definition: vehicle_base.h:264
StationID last_station_visited
The last station we stopped at.
Definition: vehicle_base.h:337
TimerGameCalendar::Year build_year
Year the vehicle has been built.
Definition: vehicle_base.h:291
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:309
Representation of a waypoint.
Definition: waypoint_base.h:23
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:564
void RebuildSubsidisedSourceAndDestinationCache()
Perform a full rebuild of the subsidies cache.
Definition: subsidy.cpp:134
Subsidy base class.
Functions related to subsidies.
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition: tile_map.h:214
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:15
@ MP_STATION
A tile of a station.
Definition: tile_type.h:53
@ MP_RAILWAY
A railway.
Definition: tile_type.h:49
Definition of Interval and OneShot timers.
Definition of the game-calendar-timer.
Definition of the game-economy-timer.
Base of the town class.
static constexpr int RATING_INITIAL
initial rating
Definition: town_type.h:43
Track RemoveFirstTrack(TrackBits *tracks)
Removes first Track from TrackBits and returns it.
Definition: track_func.h:131
TrackBits
Allow incrementing of Track variables.
Definition: track_type.h:35
@ TRACK_BIT_NONE
No track.
Definition: track_type.h:36
Track
These are used to specify a single track.
Definition: track_type.h:19
Base for the train class.
uint8_t CalcPercentVehicleFilled(const Vehicle *front, StringID *colour)
Calculates how full a vehicle is.
Definition: vehicle.cpp:1493
@ VF_STOP_LOADING
Don't load anymore during the next load cycle.
Definition: vehicle_base.h:51
@ VF_CARGO_UNLOADING
Vehicle is unloading cargo.
Definition: vehicle_base.h:46
@ VF_LOADING_FINISHED
Vehicle has finished loading.
Definition: vehicle_base.h:45
@ VS_STOPPED
Vehicle is stopped by the player.
Definition: vehicle_base.h:34
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:40
Command definitions for vehicles.
Functions related to vehicles.
static const TimerGameEconomy::Date VEHICLE_PROFIT_MIN_AGE
Only vehicles older than this have a meaningful profit.
Definition: vehicle_func.h:28
bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
Definition: vehicle_func.h:91
WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition: vehicle_gui.h:97
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
Functions related to water (management)
Money CanalMaintenanceCost(uint32_t num)
Calculates the maintenance cost of a number of canal tiles.
Definition: water.h:51
Base of waypoints.
void ChangeWindowOwner(Owner old_owner, Owner new_owner)
Change the owner of all the windows one company can take over from another company in the case of a c...
Definition: window.cpp:1188
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting)
Definition: window.cpp:3119
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:3211
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
Definition: window.cpp:3093
void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
Mark window data of all windows of a given class as invalid (in need of re-computing) Note that by de...
Definition: window.cpp:3228
@ WC_PERFORMANCE_HISTORY
Performance history graph; Window numbers:
Definition: window_type.h:551
@ WC_COMPANY_LEAGUE
Company league window; Window numbers:
Definition: window_type.h:563
@ WC_COMPANY_INFRASTRUCTURE
Company infrastructure overview; Window numbers:
Definition: window_type.h:587
@ WC_PERFORMANCE_DETAIL
Performance detail window; Window numbers:
Definition: window_type.h:575
@ WC_PAYMENT_RATES
Payment rates graph; Window numbers:
Definition: window_type.h:569
@ WC_STATION_LIST
Station list; Window numbers:
Definition: window_type.h:302
@ WC_ROADVEH_LIST
Road vehicle list; Window numbers:
Definition: window_type.h:314
@ WC_REPLACE_VEHICLE
Replace vehicle window; Window numbers:
Definition: window_type.h:218
@ WC_SHIPS_LIST
Ships list; Window numbers:
Definition: window_type.h:320
@ WC_STATION_VIEW
Station view; Window numbers:
Definition: window_type.h:345
@ WC_OPERATING_PROFIT
Operating profit graph; Window numbers:
Definition: window_type.h:539
@ WC_TRAINS_LIST
Trains list; Window numbers:
Definition: window_type.h:308
@ WC_INDUSTRY_VIEW
Industry view; Window numbers:
Definition: window_type.h:363
@ WC_INCOME_GRAPH
Income graph; Window numbers:
Definition: window_type.h:533
@ WC_DELIVERED_CARGO
Delivered cargo graph; Window numbers:
Definition: window_type.h:545
@ WC_COMPANY_VALUE
Company value graph; Window numbers:
Definition: window_type.h:557
@ WC_VEHICLE_DETAILS
Vehicle details; Window numbers:
Definition: window_type.h:200
@ WC_BUILD_VEHICLE
Build vehicle; Window numbers:
Definition: window_type.h:389
@ WC_AIRCRAFT_LIST
Aircraft list; Window numbers:
Definition: window_type.h:326