OpenTTD
economy.cpp
Go to the documentation of this file.
1 /* $Id: economy.cpp 27893 2017-08-13 18:38:42Z frosch $ */
2 
3 /*
4  * This file is part of OpenTTD.
5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
8  */
9 
12 #include "stdafx.h"
13 #include "company_func.h"
14 #include "command_func.h"
15 #include "industry.h"
16 #include "town.h"
17 #include "news_func.h"
18 #include "network/network.h"
19 #include "network/network_func.h"
20 #include "ai/ai.hpp"
21 #include "aircraft.h"
22 #include "train.h"
23 #include "newgrf_engine.h"
24 #include "engine_base.h"
25 #include "ground_vehicle.hpp"
26 #include "newgrf_cargo.h"
27 #include "newgrf_sound.h"
28 #include "newgrf_industrytiles.h"
29 #include "newgrf_station.h"
30 #include "newgrf_airporttiles.h"
31 #include "object.h"
32 #include "strings_func.h"
33 #include "date_func.h"
34 #include "vehicle_func.h"
35 #include "sound_func.h"
36 #include "autoreplace_func.h"
37 #include "company_gui.h"
38 #include "signs_base.h"
39 #include "subsidy_base.h"
40 #include "subsidy_func.h"
41 #include "station_base.h"
42 #include "waypoint_base.h"
43 #include "economy_base.h"
44 #include "core/pool_func.hpp"
45 #include "core/backup_type.hpp"
46 #include "cargo_type.h"
47 #include "water.h"
48 #include "game/game.hpp"
49 #include "cargomonitor.h"
50 #include "goal_base.h"
51 #include "story_base.h"
52 #include "linkgraph/refresh.h"
53 
54 #include "table/strings.h"
55 #include "table/pricebase.h"
56 
57 #include "safeguards.h"
58 
59 
60 /* Initialize the cargo payment-pool */
63 
64 
75 static inline int32 BigMulS(const int32 a, const int32 b, const uint8 shift)
76 {
77  return (int32)((int64)a * (int64)b >> shift);
78 }
79 
81 
86  { 120, 100}, // SCORE_VEHICLES
87  { 80, 100}, // SCORE_STATIONS
88  { 10000, 100}, // SCORE_MIN_PROFIT
89  { 50000, 50}, // SCORE_MIN_INCOME
90  { 100000, 100}, // SCORE_MAX_INCOME
91  { 40000, 400}, // SCORE_DELIVERED
92  { 8, 50}, // SCORE_CARGO
93  {10000000, 50}, // SCORE_MONEY
94  { 250000, 50}, // SCORE_LOAN
95  { 0, 0} // SCORE_TOTAL
96 };
97 
98 int _score_part[MAX_COMPANIES][SCORE_END];
99 Economy _economy;
100 Prices _price;
101 Money _additional_cash_required;
102 static PriceMultipliers _price_base_multiplier;
103 
113 Money CalculateCompanyValue(const Company *c, bool including_loan)
114 {
115  Owner owner = c->index;
116 
117  Station *st;
118  uint num = 0;
119 
120  FOR_ALL_STATIONS(st) {
121  if (st->owner == owner) num += CountBits((byte)st->facilities);
122  }
123 
124  Money value = num * _price[PR_STATION_VALUE] * 25;
125 
126  Vehicle *v;
127  FOR_ALL_VEHICLES(v) {
128  if (v->owner != owner) continue;
129 
130  if (v->type == VEH_TRAIN ||
131  v->type == VEH_ROAD ||
133  v->type == VEH_SHIP) {
134  value += v->value * 3 >> 1;
135  }
136  }
137 
138  /* Add real money value */
139  if (including_loan) value -= c->current_loan;
140  value += c->money;
141 
142  return max(value, (Money)1);
143 }
144 
154 {
155  Owner owner = c->index;
156  int score = 0;
157 
158  memset(_score_part[owner], 0, sizeof(_score_part[owner]));
159 
160  /* Count vehicles */
161  {
162  Vehicle *v;
163  Money min_profit = 0;
164  bool min_profit_first = true;
165  uint num = 0;
166 
167  FOR_ALL_VEHICLES(v) {
168  if (v->owner != owner) continue;
170  if (v->profit_last_year > 0) num++; // For the vehicle score only count profitable vehicles
171  if (v->age > 730) {
172  /* Find the vehicle with the lowest amount of profit */
173  if (min_profit_first || min_profit > v->profit_last_year) {
174  min_profit = v->profit_last_year;
175  min_profit_first = false;
176  }
177  }
178  }
179  }
180 
181  min_profit >>= 8; // remove the fract part
182 
183  _score_part[owner][SCORE_VEHICLES] = num;
184  /* Don't allow negative min_profit to show */
185  if (min_profit > 0) {
186  _score_part[owner][SCORE_MIN_PROFIT] = ClampToI32(min_profit);
187  }
188  }
189 
190  /* Count stations */
191  {
192  uint num = 0;
193  const Station *st;
194 
195  FOR_ALL_STATIONS(st) {
196  /* Only count stations that are actually serviced */
197  if (st->owner == owner && (st->time_since_load <= 20 || st->time_since_unload <= 20)) num += CountBits((byte)st->facilities);
198  }
199  _score_part[owner][SCORE_STATIONS] = num;
200  }
201 
202  /* Generate statistics depending on recent income statistics */
203  {
204  int numec = min(c->num_valid_stat_ent, 12);
205  if (numec != 0) {
206  const CompanyEconomyEntry *cee = c->old_economy;
207  Money min_income = cee->income + cee->expenses;
208  Money max_income = cee->income + cee->expenses;
209 
210  do {
211  min_income = min(min_income, cee->income + cee->expenses);
212  max_income = max(max_income, cee->income + cee->expenses);
213  } while (++cee, --numec);
214 
215  if (min_income > 0) {
216  _score_part[owner][SCORE_MIN_INCOME] = ClampToI32(min_income);
217  }
218 
219  _score_part[owner][SCORE_MAX_INCOME] = ClampToI32(max_income);
220  }
221  }
222 
223  /* Generate score depending on amount of transported cargo */
224  {
225  int numec = min(c->num_valid_stat_ent, 4);
226  if (numec != 0) {
227  const CompanyEconomyEntry *cee = c->old_economy;
228  OverflowSafeInt64 total_delivered = 0;
229  do {
230  total_delivered += cee->delivered_cargo.GetSum<OverflowSafeInt64>();
231  } while (++cee, --numec);
232 
233  _score_part[owner][SCORE_DELIVERED] = ClampToI32(total_delivered);
234  }
235  }
236 
237  /* Generate score for variety of cargo */
238  {
239  _score_part[owner][SCORE_CARGO] = c->old_economy->delivered_cargo.GetCount();
240  }
241 
242  /* Generate score for company's money */
243  {
244  if (c->money > 0) {
245  _score_part[owner][SCORE_MONEY] = ClampToI32(c->money);
246  }
247  }
248 
249  /* Generate score for loan */
250  {
251  _score_part[owner][SCORE_LOAN] = ClampToI32(_score_info[SCORE_LOAN].needed - c->current_loan);
252  }
253 
254  /* Now we calculate the score for each item.. */
255  {
256  int total_score = 0;
257  int s;
258  score = 0;
259  for (ScoreID i = SCORE_BEGIN; i < SCORE_END; i++) {
260  /* Skip the total */
261  if (i == SCORE_TOTAL) continue;
262  /* Check the score */
263  s = Clamp(_score_part[owner][i], 0, _score_info[i].needed) * _score_info[i].score / _score_info[i].needed;
264  score += s;
265  total_score += _score_info[i].score;
266  }
267 
268  _score_part[owner][SCORE_TOTAL] = score;
269 
270  /* We always want the score scaled to SCORE_MAX (1000) */
271  if (total_score != SCORE_MAX) score = score * SCORE_MAX / total_score;
272  }
273 
274  if (update) {
275  c->old_economy[0].performance_history = score;
276  UpdateCompanyHQ(c->location_of_HQ, score);
278  }
279 
281  return score;
282 }
283 
289 void ChangeOwnershipOfCompanyItems(Owner old_owner, Owner new_owner)
290 {
291  /* We need to set _current_company to old_owner before we try to move
292  * the client. This is needed as it needs to know whether "you" really
293  * are the current local company. */
294  Backup<CompanyByte> cur_company(_current_company, old_owner, FILE_LINE);
295 #ifdef ENABLE_NETWORK
296  /* In all cases, make spectators of clients connected to that company */
297  if (_networking) NetworkClientsToSpectators(old_owner);
298 #endif /* ENABLE_NETWORK */
299  if (old_owner == _local_company) {
300  /* Single player cheated to AI company.
301  * There are no spectators in single player, so we must pick some other company. */
302  assert(!_networking);
303  Backup<CompanyByte> cur_company2(_current_company, FILE_LINE);
304  Company *c;
305  FOR_ALL_COMPANIES(c) {
306  if (c->index != old_owner) {
308  break;
309  }
310  }
311  cur_company2.Restore();
312  assert(old_owner != _local_company);
313  }
314 
315  Town *t;
316 
317  assert(old_owner != new_owner);
318 
319  {
320  Company *c;
321  uint i;
322 
323  /* See if the old_owner had shares in other companies */
324  FOR_ALL_COMPANIES(c) {
325  for (i = 0; i < 4; i++) {
326  if (c->share_owners[i] == old_owner) {
327  /* Sell his shares */
329  /* Because we are in a DoCommand, we can't just execute another one and
330  * expect the money to be removed. We need to do it ourself! */
332  }
333  }
334  }
335 
336  /* Sell all the shares that people have on this company */
337  Backup<CompanyByte> cur_company2(_current_company, FILE_LINE);
338  c = Company::Get(old_owner);
339  for (i = 0; i < 4; i++) {
340  cur_company2.Change(c->share_owners[i]);
342  /* Sell the shares */
344  /* Because we are in a DoCommand, we can't just execute another one and
345  * expect the money to be removed. We need to do it ourself! */
347  }
348  }
349  cur_company2.Restore();
350  }
351 
352  /* Temporarily increase the company's money, to be sure that
353  * removing his/her property doesn't fail because of lack of money.
354  * Not too drastically though, because it could overflow */
355  if (new_owner == INVALID_OWNER) {
356  Company::Get(old_owner)->money = UINT64_MAX >> 2; // jackpot ;p
357  }
358 
359  Subsidy *s;
360  FOR_ALL_SUBSIDIES(s) {
361  if (s->awarded == old_owner) {
362  if (new_owner == INVALID_OWNER) {
363  delete s;
364  } else {
365  s->awarded = new_owner;
366  }
367  }
368  }
370 
371  /* Take care of rating and transport rights in towns */
372  FOR_ALL_TOWNS(t) {
373  /* If a company takes over, give the ratings to that company. */
374  if (new_owner != INVALID_OWNER) {
375  if (HasBit(t->have_ratings, old_owner)) {
376  if (HasBit(t->have_ratings, new_owner)) {
377  /* use max of the two ratings. */
378  t->ratings[new_owner] = max(t->ratings[new_owner], t->ratings[old_owner]);
379  } else {
380  SetBit(t->have_ratings, new_owner);
381  t->ratings[new_owner] = t->ratings[old_owner];
382  }
383  }
384  }
385 
386  /* Reset the ratings for the old owner */
387  t->ratings[old_owner] = RATING_INITIAL;
388  ClrBit(t->have_ratings, old_owner);
389 
390  /* Transfer exclusive rights */
391  if (t->exclusive_counter > 0 && t->exclusivity == old_owner) {
392  if (new_owner != INVALID_OWNER) {
393  t->exclusivity = new_owner;
394  } else {
395  t->exclusive_counter = 0;
397  }
398  }
399  }
400 
401  {
402  Vehicle *v;
403  FOR_ALL_VEHICLES(v) {
404  if (v->owner == old_owner && IsCompanyBuildableVehicleType(v->type)) {
405  if (new_owner == INVALID_OWNER) {
406  if (v->Previous() == NULL) delete v;
407  } else {
410  }
411  }
412  }
413  }
414 
415  /* In all cases clear replace engine rules.
416  * Even if it was copied, it could interfere with new owner's rules */
418 
419  if (new_owner == INVALID_OWNER) {
420  RemoveAllGroupsForCompany(old_owner);
421  } else {
422  Group *g;
423  FOR_ALL_GROUPS(g) {
424  if (g->owner == old_owner) g->owner = new_owner;
425  }
426  }
427 
428  {
429  FreeUnitIDGenerator unitidgen[] = {
432  };
433 
434  /* Override company settings to new company defaults in case we need to convert them.
435  * This is required as the CmdChangeServiceInt doesn't copy the supplied value when it is non-custom
436  */
437  if (new_owner != INVALID_OWNER) {
438  Company *old_company = Company::Get(old_owner);
439  Company *new_company = Company::Get(new_owner);
440 
442  old_company->settings.vehicle.servint_trains = new_company->settings.vehicle.servint_trains;
443  old_company->settings.vehicle.servint_roadveh = new_company->settings.vehicle.servint_roadveh;
444  old_company->settings.vehicle.servint_ships = new_company->settings.vehicle.servint_ships;
446  }
447 
448  Vehicle *v;
449  FOR_ALL_VEHICLES(v) {
450  if (v->owner == old_owner && IsCompanyBuildableVehicleType(v->type)) {
451  assert(new_owner != INVALID_OWNER);
452 
453  /* Correct default values of interval settings while maintaining custom set ones.
454  * This prevents invalid values on mismatching company defaults being accepted.
455  */
456  if (!v->ServiceIntervalIsCustom()) {
457  Company *new_company = Company::Get(new_owner);
458 
459  /* Technically, passing the interval is not needed as the command will query the default value itself.
460  * However, do not rely on that behaviour.
461  */
462  int interval = CompanyServiceInterval(new_company, v->type);
463  DoCommand(v->tile, v->index, interval | (new_company->settings.vehicle.servint_ispercent << 17), DC_EXEC | DC_BANKRUPT, CMD_CHANGE_SERVICE_INT);
464  }
465 
466  v->owner = new_owner;
467 
468  /* Owner changes, clear cache */
469  v->colourmap = PAL_NONE;
471 
472  if (v->IsEngineCountable()) {
474  }
475  if (v->IsPrimaryVehicle()) {
477  v->unitnumber = unitidgen[v->type].NextID();
478  }
479 
480  /* Invalidate the vehicle's cargo payment "owner cache". */
481  if (v->cargo_payment != NULL) v->cargo_payment->owner = NULL;
482  }
483  }
484 
485  if (new_owner != INVALID_OWNER) GroupStatistics::UpdateAutoreplace(new_owner);
486  }
487 
488  /* Change ownership of tiles */
489  {
490  TileIndex tile = 0;
491  do {
492  ChangeTileOwner(tile, old_owner, new_owner);
493  } while (++tile != MapSize());
494 
495  if (new_owner != INVALID_OWNER) {
496  /* Update all signals because there can be new segment that was owned by two companies
497  * and signals were not propagated
498  * Similar with crossings - it is needed to bar crossings that weren't before
499  * because of different owner of crossing and approaching train */
500  tile = 0;
501 
502  do {
503  if (IsTileType(tile, MP_RAILWAY) && IsTileOwner(tile, new_owner) && HasSignals(tile)) {
504  TrackBits tracks = GetTrackBits(tile);
505  do { // there may be two tracks with signals for TRACK_BIT_HORZ and TRACK_BIT_VERT
506  Track track = RemoveFirstTrack(&tracks);
507  if (HasSignalOnTrack(tile, track)) AddTrackToSignalBuffer(tile, track, new_owner);
508  } while (tracks != TRACK_BIT_NONE);
509  } else if (IsLevelCrossingTile(tile) && IsTileOwner(tile, new_owner)) {
510  UpdateLevelCrossing(tile);
511  }
512  } while (++tile != MapSize());
513  }
514 
515  /* update signals in buffer */
517  }
518 
519  /* Add airport infrastructure count of the old company to the new one. */
520  if (new_owner != INVALID_OWNER) Company::Get(new_owner)->infrastructure.airport += Company::Get(old_owner)->infrastructure.airport;
521 
522  /* convert owner of stations (including deleted ones, but excluding buoys) */
523  Station *st;
524  FOR_ALL_STATIONS(st) {
525  if (st->owner == old_owner) {
526  /* if a company goes bankrupt, set owner to OWNER_NONE so the sign doesn't disappear immediately
527  * also, drawing station window would cause reading invalid company's colour */
528  st->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
529  }
530  }
531 
532  /* do the same for waypoints (we need to do this here so deleted waypoints are converted too) */
533  Waypoint *wp;
534  FOR_ALL_WAYPOINTS(wp) {
535  if (wp->owner == old_owner) {
536  wp->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
537  }
538  }
539 
540  Sign *si;
541  FOR_ALL_SIGNS(si) {
542  if (si->owner == old_owner) si->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
543  }
544 
545  /* Remove Game Script created Goals, CargoMonitors and Story pages. */
546  Goal *g;
547  FOR_ALL_GOALS(g) {
548  if (g->company == old_owner) delete g;
549  }
550 
551  ClearCargoPickupMonitoring(old_owner);
552  ClearCargoDeliveryMonitoring(old_owner);
553 
554  StoryPage *sp;
555  FOR_ALL_STORY_PAGES(sp) {
556  if (sp->company == old_owner) delete sp;
557  }
558 
559  /* Change colour of existing windows */
560  if (new_owner != INVALID_OWNER) ChangeWindowOwner(old_owner, new_owner);
561 
562  cur_company.Restore();
563 
565 }
566 
572 {
573  /* If the company has money again, it does not go bankrupt */
574  if (c->money - c->current_loan >= -_economy.max_loan) {
575  c->months_of_bankruptcy = 0;
576  c->bankrupt_asked = 0;
577  return;
578  }
579 
581 
582  switch (c->months_of_bankruptcy) {
583  /* All the boring cases (months) with a bad balance where no action is taken */
584  case 0:
585  case 1:
586  case 2:
587  case 3:
588 
589  case 5:
590  case 6:
591 
592  case 8:
593  case 9:
594  break;
595 
596  /* Warn about bankruptcy after 3 months */
597  case 4: {
598  CompanyNewsInformation *cni = MallocT<CompanyNewsInformation>(1);
599  cni->FillData(c);
600  SetDParam(0, STR_NEWS_COMPANY_IN_TROUBLE_TITLE);
601  SetDParam(1, STR_NEWS_COMPANY_IN_TROUBLE_DESCRIPTION);
602  SetDParamStr(2, cni->company_name);
603  AddCompanyNewsItem(STR_MESSAGE_NEWS_FORMAT, cni);
604  AI::BroadcastNewEvent(new ScriptEventCompanyInTrouble(c->index));
605  Game::NewEvent(new ScriptEventCompanyInTrouble(c->index));
606  break;
607  }
608 
609  /* Offer company for sale after 6 months */
610  case 7: {
611  /* Don't consider the loan */
612  Money val = CalculateCompanyValue(c, false);
613 
614  c->bankrupt_value = val;
615  c->bankrupt_asked = 1 << c->index; // Don't ask the owner
616  c->bankrupt_timeout = 0;
617 
618  /* The company assets should always have some value */
619  assert(c->bankrupt_value > 0);
620  break;
621  }
622 
623  /* Bankrupt company after 6 months (if the company has no value) or latest
624  * after 9 months (if it still had value after 6 months) */
625  default:
626  case 10: {
627  if (!_networking && _local_company == c->index) {
628  /* If we are in offline mode, leave the company playing. Eg. there
629  * is no THE-END, otherwise mark the client as spectator to make sure
630  * he/she is no long in control of this company. However... when you
631  * join another company (cheat) the "unowned" company can bankrupt. */
632  c->bankrupt_asked = MAX_UVALUE(CompanyMask);
633  break;
634  }
635 
636  /* Actually remove the company, but not when we're a network client.
637  * In case of network clients we will be getting a command from the
638  * server. It is done in this way as we are called from the
639  * StateGameLoop which can't change the current company, and thus
640  * updating the local company triggers an assert later on. In the
641  * case of a network game the command will be processed at a time
642  * that changing the current company is okay. In case of single
643  * player we are sure (the above check) that we are not the local
644  * company and thus we won't be moved. */
646  break;
647  }
648  }
649 }
650 
656 {
657  Station *st;
658 
659  Backup<CompanyByte> cur_company(_current_company, FILE_LINE);
660  Company *c;
661 
663  FOR_ALL_STATIONS(st) {
664  cur_company.Change(st->owner);
665  CommandCost cost(EXPENSES_PROPERTY, _price[PR_STATION_VALUE] >> 1);
667  }
668  } else {
669  /* Improved monthly infrastructure costs. */
670  FOR_ALL_COMPANIES(c) {
671  cur_company.Change(c->index);
672 
674  uint32 rail_total = c->infrastructure.GetRailTotal();
675  for (RailType rt = RAILTYPE_BEGIN; rt < RAILTYPE_END; rt++) {
676  if (c->infrastructure.rail[rt] != 0) cost.AddCost(RailMaintenanceCost(rt, c->infrastructure.rail[rt], rail_total));
677  }
679  for (RoadType rt = ROADTYPE_BEGIN; rt < ROADTYPE_END; rt++) {
680  if (c->infrastructure.road[rt] != 0) cost.AddCost(RoadMaintenanceCost(rt, c->infrastructure.road[rt]));
681  }
685 
687  }
688  }
689  cur_company.Restore();
690 
691  /* Check for bankruptcy each month */
692  FOR_ALL_COMPANIES(c) {
694  }
695 
696  /* Only run the economic statics and update company stats every 3rd month (1st of quarter). */
697  if (!HasBit(1 << 0 | 1 << 3 | 1 << 6 | 1 << 9, _cur_month)) return;
698 
699  FOR_ALL_COMPANIES(c) {
700  memmove(&c->old_economy[1], &c->old_economy[0], sizeof(c->old_economy) - sizeof(c->old_economy[0]));
701  c->old_economy[0] = c->cur_economy;
702  memset(&c->cur_economy, 0, sizeof(c->cur_economy));
703 
705 
707  if (c->block_preview != 0) c->block_preview--;
708  }
709 
716 }
717 
723 bool AddInflation(bool check_year)
724 {
725  /* The cargo payment inflation differs from the normal inflation, so the
726  * relative amount of money you make with a transport decreases slowly over
727  * the 170 years. After a few hundred years we reach a level in which the
728  * games will become unplayable as the maximum income will be less than
729  * the minimum running cost.
730  *
731  * Furthermore there are a lot of inflation related overflows all over the
732  * place. Solving them is hardly possible because inflation will always
733  * reach the overflow threshold some day. So we'll just perform the
734  * inflation mechanism during the first 170 years (the amount of years that
735  * one had in the original TTD) and stop doing the inflation after that
736  * because it only causes problems that can't be solved nicely and the
737  * inflation doesn't add anything after that either; it even makes playing
738  * it impossible due to the diverging cost and income rates.
739  */
741 
742  if (_economy.inflation_prices == MAX_INFLATION || _economy.inflation_payment == MAX_INFLATION) return true;
743 
744  /* Approximation for (100 + infl_amount)% ** (1 / 12) - 100%
745  * scaled by 65536
746  * 12 -> months per year
747  * This is only a good approximation for small values
748  */
749  _economy.inflation_prices += (_economy.inflation_prices * _economy.infl_amount * 54) >> 16;
750  _economy.inflation_payment += (_economy.inflation_payment * _economy.infl_amount_pr * 54) >> 16;
751 
754 
755  return false;
756 }
757 
762 {
763  /* Setup maximum loan */
764  _economy.max_loan = (_settings_game.difficulty.max_loan * _economy.inflation_prices >> 16) / 50000 * 50000;
765 
766  /* Setup price bases */
767  for (Price i = PR_BEGIN; i < PR_END; i++) {
768  Money price = _price_base_specs[i].start_price;
769 
770  /* Apply difficulty settings */
771  uint mod = 1;
772  switch (_price_base_specs[i].category) {
773  case PCAT_RUNNING:
775  break;
776 
777  case PCAT_CONSTRUCTION:
779  break;
780 
781  default: break;
782  }
783  switch (mod) {
784  case 0: price *= 6; break;
785  case 1: price *= 8; break; // normalised to 1 below
786  case 2: price *= 9; break;
787  default: NOT_REACHED();
788  }
789 
790  /* Apply inflation */
791  price = (int64)price * _economy.inflation_prices;
792 
793  /* Apply newgrf modifiers, remove fractional part of inflation, and normalise on medium difficulty. */
794  int shift = _price_base_multiplier[i] - 16 - 3;
795  if (shift >= 0) {
796  price <<= shift;
797  } else {
798  price >>= -shift;
799  }
800 
801  /* Make sure the price does not get reduced to zero.
802  * Zero breaks quite a few commands that use a zero
803  * cost to see whether something got changed or not
804  * and based on that cause an error. When the price
805  * is zero that fails even when things are done. */
806  if (price == 0) {
807  price = Clamp(_price_base_specs[i].start_price, -1, 1);
808  /* No base price should be zero, but be sure. */
809  assert(price != 0);
810  }
811  /* Store value */
812  _price[i] = price;
813  }
814 
815  /* Setup cargo payment */
816  CargoSpec *cs;
817  FOR_ALL_CARGOSPECS(cs) {
818  cs->current_payment = ((int64)cs->initial_payment * _economy.inflation_payment) >> 16;
819  }
820 
826 }
827 
829 static void CompaniesPayInterest()
830 {
831  const Company *c;
832 
833  Backup<CompanyByte> cur_company(_current_company, FILE_LINE);
834  FOR_ALL_COMPANIES(c) {
835  cur_company.Change(c->index);
836 
837  /* Over a year the paid interest should be "loan * interest percentage",
838  * but... as that number is likely not dividable by 12 (pay each month),
839  * one needs to account for that in the monthly fee calculations.
840  * To easily calculate what one should pay "this" month, you calculate
841  * what (total) should have been paid up to this month and you subtract
842  * whatever has been paid in the previous months. This will mean one month
843  * it'll be a bit more and the other it'll be a bit less than the average
844  * monthly fee, but on average it will be exact.
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  */
848  Money yearly_fee = c->current_loan * _economy.interest_rate / 100;
849  if (c->money < 0) {
850  yearly_fee += -c->money *_economy.interest_rate / 100;
851  }
852  Money up_to_previous_month = yearly_fee * _cur_month / 12;
853  Money up_to_this_month = yearly_fee * (_cur_month + 1) / 12;
854 
855  SubtractMoneyFromCompany(CommandCost(EXPENSES_LOAN_INT, up_to_this_month - up_to_previous_month));
856 
857  SubtractMoneyFromCompany(CommandCost(EXPENSES_OTHER, _price[PR_STATION_VALUE] >> 2));
858  }
859  cur_company.Restore();
860 }
861 
862 static void HandleEconomyFluctuations()
863 {
864  if (_settings_game.difficulty.economy != 0) {
865  /* When economy is Fluctuating, decrease counter */
866  _economy.fluct--;
867  } else if (EconomyIsInRecession()) {
868  /* When it's Steady and we are in recession, end it now */
869  _economy.fluct = -12;
870  } else {
871  /* No need to do anything else in other cases */
872  return;
873  }
874 
875  if (_economy.fluct == 0) {
876  _economy.fluct = -(int)GB(Random(), 0, 2);
877  AddNewsItem(STR_NEWS_BEGIN_OF_RECESSION, NT_ECONOMY, NF_NORMAL);
878  } else if (_economy.fluct == -12) {
879  _economy.fluct = GB(Random(), 0, 8) + 312;
880  AddNewsItem(STR_NEWS_END_OF_RECESSION, NT_ECONOMY, NF_NORMAL);
881  }
882 }
883 
884 
889 {
890  memset(_price_base_multiplier, 0, sizeof(_price_base_multiplier));
891 }
892 
900 void SetPriceBaseMultiplier(Price price, int factor)
901 {
902  assert(price < PR_END);
903  _price_base_multiplier[price] = Clamp(factor, MIN_PRICE_MODIFIER, MAX_PRICE_MODIFIER);
904 }
905 
910 void StartupIndustryDailyChanges(bool init_counter)
911 {
912  uint map_size = MapLogX() + MapLogY();
913  /* After getting map size, it needs to be scaled appropriately and divided by 31,
914  * which stands for the days in a month.
915  * Using just 31 will make it so that a monthly reset (based on the real number of days of that month)
916  * would not be needed.
917  * Since it is based on "fractional parts", the leftover days will not make much of a difference
918  * on the overall total number of changes performed */
919  _economy.industry_daily_increment = (1 << map_size) / 31;
920 
921  if (init_counter) {
922  /* A new game or a savegame from an older version will require the counter to be initialized */
923  _economy.industry_daily_change_counter = 0;
924  }
925 }
926 
927 void StartupEconomy()
928 {
932  _economy.fluct = GB(Random(), 0, 8) + 168;
933 
934  /* Set up prices */
935  RecomputePrices();
936 
937  StartupIndustryDailyChanges(true); // As we are starting a new game, initialize the counter too
938 
939 }
940 
945 {
946  _economy.inflation_prices = _economy.inflation_payment = 1 << 16;
949 }
950 
959 Money GetPrice(Price index, uint cost_factor, const GRFFile *grf_file, int shift)
960 {
961  if (index >= PR_END) return 0;
962 
963  Money cost = _price[index] * cost_factor;
964  if (grf_file != NULL) shift += grf_file->price_base_multipliers[index];
965 
966  if (shift >= 0) {
967  cost <<= shift;
968  } else {
969  cost >>= -shift;
970  }
971 
972  return cost;
973 }
974 
975 Money GetTransportedGoodsIncome(uint num_pieces, uint dist, byte transit_days, CargoID cargo_type)
976 {
977  const CargoSpec *cs = CargoSpec::Get(cargo_type);
978  if (!cs->IsValid()) {
979  /* User changed newgrfs and some vehicle still carries some cargo which is no longer available. */
980  return 0;
981  }
982 
983  /* Use callback to calculate cargo profit, if available */
985  uint32 var18 = min(dist, 0xFFFF) | (min(num_pieces, 0xFF) << 16) | (transit_days << 24);
986  uint16 callback = GetCargoCallback(CBID_CARGO_PROFIT_CALC, 0, var18, cs);
987  if (callback != CALLBACK_FAILED) {
988  int result = GB(callback, 0, 14);
989 
990  /* Simulate a 15 bit signed value */
991  if (HasBit(callback, 14)) result -= 0x4000;
992 
993  /* "The result should be a signed multiplier that gets multiplied
994  * by the amount of cargo moved and the price factor, then gets
995  * divided by 8192." */
996  return result * num_pieces * cs->current_payment / 8192;
997  }
998  }
999 
1000  static const int MIN_TIME_FACTOR = 31;
1001  static const int MAX_TIME_FACTOR = 255;
1002 
1003  const int days1 = cs->transit_days[0];
1004  const int days2 = cs->transit_days[1];
1005  const int days_over_days1 = max( transit_days - days1, 0);
1006  const int days_over_days2 = max(days_over_days1 - days2, 0);
1007 
1008  /*
1009  * The time factor is calculated based on the time it took
1010  * (transit_days) compared two cargo-depending values. The
1011  * range is divided into three parts:
1012  *
1013  * - constant for fast transits
1014  * - linear decreasing with time with a slope of -1 for medium transports
1015  * - linear decreasing with time with a slope of -2 for slow transports
1016  *
1017  */
1018  const int time_factor = max(MAX_TIME_FACTOR - days_over_days1 - days_over_days2, MIN_TIME_FACTOR);
1019 
1020  return BigMulS(dist * time_factor * num_pieces, cs->current_payment, 21);
1021 }
1022 
1025 
1035 static uint DeliverGoodsToIndustry(const Station *st, CargoID cargo_type, uint num_pieces, IndustryID source)
1036 {
1037  /* Find the nearest industrytile to the station sign inside the catchment area, whose industry accepts the cargo.
1038  * This fails in three cases:
1039  * 1) The station accepts the cargo because there are enough houses around it accepting the cargo.
1040  * 2) The industries in the catchment area temporarily reject the cargo, and the daily station loop has not yet updated station acceptance.
1041  * 3) The results of callbacks CBID_INDUSTRY_REFUSE_CARGO and CBID_INDTILE_CARGO_ACCEPTANCE are inconsistent. (documented behaviour)
1042  */
1043 
1044  uint accepted = 0;
1045 
1046  for (uint i = 0; i < st->industries_near.Length() && num_pieces != 0; i++) {
1047  Industry *ind = st->industries_near[i];
1048  if (ind->index == source) continue;
1049 
1050  uint cargo_index;
1051  for (cargo_index = 0; cargo_index < lengthof(ind->accepts_cargo); cargo_index++) {
1052  if (cargo_type == ind->accepts_cargo[cargo_index]) break;
1053  }
1054  /* Check if matching cargo has been found */
1055  if (cargo_index >= lengthof(ind->accepts_cargo)) continue;
1056 
1057  /* Check if industry temporarily refuses acceptance */
1058  if (IndustryTemporarilyRefusesCargo(ind, cargo_type)) continue;
1059 
1060  /* Insert the industry into _cargo_delivery_destinations, if not yet contained */
1061  _cargo_delivery_destinations.Include(ind);
1062 
1063  uint amount = min(num_pieces, 0xFFFFU - ind->incoming_cargo_waiting[cargo_index]);
1064  ind->incoming_cargo_waiting[cargo_index] += amount;
1065  num_pieces -= amount;
1066  accepted += amount;
1067  }
1068 
1069  return accepted;
1070 }
1071 
1085 static Money DeliverGoods(int num_pieces, CargoID cargo_type, StationID dest, TileIndex source_tile, byte days_in_transit, Company *company, SourceType src_type, SourceID src)
1086 {
1087  assert(num_pieces > 0);
1088 
1089  Station *st = Station::Get(dest);
1090 
1091  /* Give the goods to the industry. */
1092  uint accepted = DeliverGoodsToIndustry(st, cargo_type, num_pieces, src_type == ST_INDUSTRY ? src : INVALID_INDUSTRY);
1093 
1094  /* If this cargo type is always accepted, accept all */
1095  if (HasBit(st->always_accepted, cargo_type)) accepted = num_pieces;
1096 
1097  /* Update station statistics */
1098  if (accepted > 0) {
1102  }
1103 
1104  /* Update company statistics */
1105  company->cur_economy.delivered_cargo[cargo_type] += accepted;
1106 
1107  /* Increase town's counter for town effects */
1108  const CargoSpec *cs = CargoSpec::Get(cargo_type);
1109  st->town->received[cs->town_effect].new_act += accepted;
1110 
1111  /* Determine profit */
1112  Money profit = GetTransportedGoodsIncome(accepted, DistanceManhattan(source_tile, st->xy), days_in_transit, cargo_type);
1113 
1114  /* Update the cargo monitor. */
1115  AddCargoDelivery(cargo_type, company->index, accepted, src_type, src, st);
1116 
1117  /* Modify profit if a subsidy is in effect */
1118  if (CheckSubsidised(cargo_type, company->index, src_type, src, st)) {
1120  case 0: profit += profit >> 1; break;
1121  case 1: profit *= 2; break;
1122  case 2: profit *= 3; break;
1123  default: profit *= 4; break;
1124  }
1125  }
1126 
1127  return profit;
1128 }
1129 
1136 {
1137  const IndustrySpec *indspec = GetIndustrySpec(i->type);
1138  uint16 callback = indspec->callback_mask;
1139 
1140  i->was_cargo_delivered = true;
1142 
1144  if (HasBit(callback, CBM_IND_PRODUCTION_CARGO_ARRIVAL)) {
1146  } else {
1148  }
1149  } else {
1150  for (uint cargo_index = 0; cargo_index < lengthof(i->incoming_cargo_waiting); cargo_index++) {
1151  uint cargo_waiting = i->incoming_cargo_waiting[cargo_index];
1152  if (cargo_waiting == 0) continue;
1153 
1154  i->produced_cargo_waiting[0] = min(i->produced_cargo_waiting[0] + (cargo_waiting * indspec->input_cargo_multiplier[cargo_index][0] / 256), 0xFFFF);
1155  i->produced_cargo_waiting[1] = min(i->produced_cargo_waiting[1] + (cargo_waiting * indspec->input_cargo_multiplier[cargo_index][1] / 256), 0xFFFF);
1156 
1157  i->incoming_cargo_waiting[cargo_index] = 0;
1158  }
1159  }
1160 
1162  StartStopIndustryTileAnimation(i, IAT_INDUSTRY_RECEIVED_CARGO);
1163 }
1164 
1170  front(front),
1171  current_station(front->last_station_visited)
1172 {
1173 }
1174 
1175 CargoPayment::~CargoPayment()
1176 {
1177  if (this->CleaningPool()) return;
1178 
1179  this->front->cargo_payment = NULL;
1180 
1181  if (this->visual_profit == 0 && this->visual_transfer == 0) return;
1182 
1183  Backup<CompanyByte> cur_company(_current_company, this->front->owner, FILE_LINE);
1184 
1186  this->front->profit_this_year += (this->visual_profit + this->visual_transfer) << 8;
1187 
1188  if (this->route_profit != 0 && IsLocalCompany() && !PlayVehicleSound(this->front, VSE_LOAD_UNLOAD)) {
1189  SndPlayVehicleFx(SND_14_CASHTILL, this->front);
1190  }
1191 
1192  if (this->visual_transfer != 0) {
1193  ShowFeederIncomeAnimation(this->front->x_pos, this->front->y_pos,
1194  this->front->z_pos, this->visual_transfer, -this->visual_profit);
1195  } else if (this->visual_profit != 0) {
1196  ShowCostOrIncomeAnimation(this->front->x_pos, this->front->y_pos,
1197  this->front->z_pos, -this->visual_profit);
1198  }
1199 
1200  cur_company.Restore();
1201 }
1202 
1208 void CargoPayment::PayFinalDelivery(const CargoPacket *cp, uint count)
1209 {
1210  if (this->owner == NULL) {
1211  this->owner = Company::Get(this->front->owner);
1212  }
1213 
1214  /* Handle end of route payment */
1215  Money profit = DeliverGoods(count, this->ct, this->current_station, cp->SourceStationXY(), cp->DaysInTransit(), this->owner, cp->SourceSubsidyType(), cp->SourceSubsidyID());
1216  this->route_profit += profit;
1217 
1218  /* The vehicle's profit is whatever route profit there is minus feeder shares. */
1219  this->visual_profit += profit - cp->FeederShare(count);
1220 }
1221 
1229 {
1230  Money profit = GetTransportedGoodsIncome(
1231  count,
1232  /* pay transfer vehicle for only the part of transfer it has done: ie. cargo_loaded_at_xy to here */
1234  cp->DaysInTransit(),
1235  this->ct);
1236 
1237  profit = profit * _settings_game.economy.feeder_payment_share / 100;
1238 
1239  this->visual_transfer += profit; // accumulate transfer profits for whole vehicle
1240  return profit; // account for the (virtual) profit already made for the cargo packet
1241 }
1242 
1248 void PrepareUnload(Vehicle *front_v)
1249 {
1250  Station *curr_station = Station::Get(front_v->last_station_visited);
1251  curr_station->loading_vehicles.push_back(front_v);
1252 
1253  /* At this moment loading cannot be finished */
1255 
1256  /* Start unloading at the first possible moment */
1257  front_v->load_unload_ticks = 1;
1258 
1259  assert(front_v->cargo_payment == NULL);
1260  /* One CargoPayment per vehicle and the vehicle limit equals the
1261  * limit in number of CargoPayments. Can't go wrong. */
1264  front_v->cargo_payment = new CargoPayment(front_v);
1265 
1266  StationIDStack next_station = front_v->GetNextStoppingStation();
1267  if (front_v->orders.list == NULL || (front_v->current_order.GetUnloadType() & OUFB_NO_UNLOAD) == 0) {
1268  Station *st = Station::Get(front_v->last_station_visited);
1269  for (Vehicle *v = front_v; v != NULL; v = v->Next()) {
1270  const GoodsEntry *ge = &st->goods[v->cargo_type];
1271  if (v->cargo_cap > 0 && v->cargo.TotalCount() > 0) {
1272  v->cargo.Stage(
1274  front_v->last_station_visited, next_station,
1275  front_v->current_order.GetUnloadType(), ge,
1276  front_v->cargo_payment);
1277  if (v->cargo.UnloadCount() > 0) SetBit(v->vehicle_flags, VF_CARGO_UNLOADING);
1278  }
1279  }
1280  }
1281 }
1282 
1289 static uint GetLoadAmount(Vehicle *v)
1290 {
1291  const Engine *e = v->GetEngine();
1292  uint load_amount = e->info.load_amount;
1293 
1294  /* The default loadamount for mail is 1/4 of the load amount for passengers */
1295  bool air_mail = v->type == VEH_AIRCRAFT && !Aircraft::From(v)->IsNormalAircraft();
1296  if (air_mail) load_amount = CeilDiv(load_amount, 4);
1297 
1299  uint16 cb_load_amount = CALLBACK_FAILED;
1300  if (e->GetGRF() != NULL && e->GetGRF()->grf_version >= 8) {
1301  /* Use callback 36 */
1302  cb_load_amount = GetVehicleProperty(v, PROP_VEHICLE_LOAD_AMOUNT, CALLBACK_FAILED);
1303  } else if (HasBit(e->info.callback_mask, CBM_VEHICLE_LOAD_AMOUNT)) {
1304  /* Use callback 12 */
1305  cb_load_amount = GetVehicleCallback(CBID_VEHICLE_LOAD_AMOUNT, 0, 0, v->engine_type, v);
1306  }
1307  if (cb_load_amount != CALLBACK_FAILED) {
1308  if (e->GetGRF()->grf_version < 8) cb_load_amount = GB(cb_load_amount, 0, 8);
1309  if (cb_load_amount >= 0x100) {
1311  } else if (cb_load_amount != 0) {
1312  load_amount = cb_load_amount;
1313  }
1314  }
1315  }
1316 
1317  /* Scale load amount the same as capacity */
1318  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);
1319 
1320  /* Zero load amount breaks a lot of things. */
1321  return max(1u, load_amount);
1322 }
1323 
1333 template<class Taction>
1334 bool IterateVehicleParts(Vehicle *v, Taction action)
1335 {
1336  for (Vehicle *w = v; w != NULL;
1337  w = w->HasArticulatedPart() ? w->GetNextArticulatedPart() : NULL) {
1338  if (!action(w)) return false;
1339  if (w->type == VEH_TRAIN) {
1340  Train *train = Train::From(w);
1341  if (train->IsMultiheaded() && !action(train->other_multiheaded_part)) return false;
1342  }
1343  }
1344  if (v->type == VEH_AIRCRAFT && Aircraft::From(v)->IsNormalAircraft()) return action(v->Next());
1345  return true;
1346 }
1347 
1352 {
1358  bool operator()(const Vehicle *v)
1359  {
1360  return v->cargo.StoredCount() == 0;
1361  }
1362 };
1363 
1368 {
1370  uint32 &refit_mask;
1371 
1378  consist_capleft(consist_capleft), refit_mask(refit_mask) {}
1379 
1386  bool operator()(const Vehicle *v)
1387  {
1388  this->consist_capleft[v->cargo_type] -= v->cargo_cap - v->cargo.ReservedCount();
1389  this->refit_mask |= EngInfo(v->engine_type)->refit_mask;
1390  return true;
1391  }
1392 };
1393 
1398 {
1400  StationID next_hop;
1401 
1407  ReturnCargoAction(Station *st, StationID next_one) : st(st), next_hop(next_one) {}
1408 
1415  {
1416  v->cargo.Return(UINT_MAX, &this->st->goods[v->cargo_type].cargo, this->next_hop);
1417  return true;
1418  }
1419 };
1420 
1425 {
1429  bool do_reserve;
1430 
1439  consist_capleft(consist_capleft), st(st), next_station(next_station), do_reserve(do_reserve) {}
1440 
1448  {
1449  if (this->do_reserve) {
1451  &v->cargo, st->xy, this->next_station);
1452  }
1453  this->consist_capleft[v->cargo_type] += v->cargo_cap - v->cargo.RemainingCount();
1454  return true;
1455  }
1456 };
1457 
1466 static void HandleStationRefit(Vehicle *v, CargoArray &consist_capleft, Station *st, StationIDStack next_station, CargoID new_cid)
1467 {
1468  Vehicle *v_start = v->GetFirstEnginePart();
1469  if (!IterateVehicleParts(v_start, IsEmptyAction())) return;
1470 
1471  Backup<CompanyByte> cur_company(_current_company, v->owner, FILE_LINE);
1472 
1473  uint32 refit_mask = v->GetEngine()->info.refit_mask;
1474 
1475  /* Remove old capacity from consist capacity and collect refit mask. */
1476  IterateVehicleParts(v_start, PrepareRefitAction(consist_capleft, refit_mask));
1477 
1478  bool is_auto_refit = new_cid == CT_AUTO_REFIT;
1479  if (is_auto_refit) {
1480  /* Get a refittable cargo type with waiting cargo for next_station or INVALID_STATION. */
1481  CargoID cid;
1482  new_cid = v_start->cargo_type;
1483  FOR_EACH_SET_CARGO_ID(cid, refit_mask) {
1484  if (st->goods[cid].cargo.HasCargoFor(next_station)) {
1485  /* Try to find out if auto-refitting would succeed. In case the refit is allowed,
1486  * the returned refit capacity will be greater than zero. */
1487  DoCommand(v_start->tile, v_start->index, cid | 1U << 6 | 0xFF << 8 | 1U << 16, DC_QUERY_COST, GetCmdRefitVeh(v_start)); // Auto-refit and only this vehicle including artic parts.
1488  /* Try to balance different loadable cargoes between parts of the consist, so that
1489  * all of them can be loaded. Avoid a situation where all vehicles suddenly switch
1490  * to the first loadable cargo for which there is only one packet. If the capacities
1491  * are equal refit to the cargo of which most is available. This is important for
1492  * consists of only a single vehicle as those will generally have a consist_capleft
1493  * of 0 for all cargoes. */
1494  if (_returned_refit_capacity > 0 && (consist_capleft[cid] < consist_capleft[new_cid] ||
1495  (consist_capleft[cid] == consist_capleft[new_cid] &&
1496  st->goods[cid].cargo.AvailableCount() > st->goods[new_cid].cargo.AvailableCount()))) {
1497  new_cid = cid;
1498  }
1499  }
1500  }
1501  }
1502 
1503  /* Refit if given a valid cargo. */
1504  if (new_cid < NUM_CARGO && new_cid != v_start->cargo_type) {
1505  /* INVALID_STATION because in the DT_MANUAL case that's correct and in the DT_(A)SYMMETRIC
1506  * cases the next hop of the vehicle doesn't really tell us anything if the cargo had been
1507  * "via any station" before reserving. We rather produce some more "any station" cargo than
1508  * misrouting it. */
1509  IterateVehicleParts(v_start, ReturnCargoAction(st, INVALID_STATION));
1510  CommandCost cost = DoCommand(v_start->tile, v_start->index, new_cid | 1U << 6 | 0xFF << 8 | 1U << 16, DC_EXEC, GetCmdRefitVeh(v_start)); // Auto-refit and only this vehicle including artic parts.
1511  if (cost.Succeeded()) v->First()->profit_this_year -= cost.GetCost() << 8;
1512  }
1513 
1514  /* Add new capacity to consist capacity and reserve cargo */
1515  IterateVehicleParts(v_start, FinalizeRefitAction(consist_capleft, st, next_station,
1516  is_auto_refit || (v->First()->current_order.GetLoadType() & OLFB_FULL_LOAD) != 0));
1517 
1518  cur_company.Restore();
1519 }
1520 
1522  Station *st;
1523  StationIDStack *next_station;
1524 
1525  ReserveCargoAction(Station *st, StationIDStack *next_station) :
1526  st(st), next_station(next_station) {}
1527 
1528  bool operator()(Vehicle *v)
1529  {
1530  if (v->cargo_cap > v->cargo.RemainingCount()) {
1532  &v->cargo, st->xy, *next_station);
1533  }
1534 
1535  return true;
1536  }
1537 
1538 };
1539 
1548 static void ReserveConsist(Station *st, Vehicle *u, CargoArray *consist_capleft, StationIDStack *next_station)
1549 {
1550  /* If there is a cargo payment not all vehicles of the consist have tried to do the refit.
1551  * In that case, only reserve if it's a fixed refit and the equivalent of "articulated chain"
1552  * a vehicle belongs to already has the right cargo. */
1553  bool must_reserve = !u->current_order.IsRefit() || u->cargo_payment == NULL;
1554  for (Vehicle *v = u; v != NULL; v = v->Next()) {
1555  assert(v->cargo_cap >= v->cargo.RemainingCount());
1556 
1557  /* Exclude various ways in which the vehicle might not be the head of an equivalent of
1558  * "articulated chain". Also don't do the reservation if the vehicle is going to refit
1559  * to a different cargo and hasn't tried to do so, yet. */
1560  if (!v->IsArticulatedPart() &&
1561  (v->type != VEH_TRAIN || !Train::From(v)->IsRearDualheaded()) &&
1562  (v->type != VEH_AIRCRAFT || Aircraft::From(v)->IsNormalAircraft()) &&
1563  (must_reserve || u->current_order.GetRefitCargo() == v->cargo_type)) {
1564  IterateVehicleParts(v, ReserveCargoAction(st, next_station));
1565  }
1566  if (consist_capleft == NULL || v->cargo_cap == 0) continue;
1567  (*consist_capleft)[v->cargo_type] += v->cargo_cap - v->cargo.RemainingCount();
1568  }
1569 }
1570 
1578 static void UpdateLoadUnloadTicks(Vehicle *front, const Station *st, int ticks)
1579 {
1580  if (front->type == VEH_TRAIN) {
1581  /* Each platform tile is worth 2 rail vehicles. */
1582  int overhang = front->GetGroundVehicleCache()->cached_total_length - st->GetPlatformLength(front->tile) * TILE_SIZE;
1583  if (overhang > 0) {
1584  ticks <<= 1;
1585  ticks += (overhang * ticks) / 8;
1586  }
1587  }
1588  /* Always wait at least 1, otherwise we'll wait 'infinitively' long. */
1589  front->load_unload_ticks = max(1, ticks);
1590 }
1591 
1596 static void LoadUnloadVehicle(Vehicle *front)
1597 {
1598  assert(front->current_order.IsType(OT_LOADING));
1599 
1600  StationID last_visited = front->last_station_visited;
1601  Station *st = Station::Get(last_visited);
1602 
1603  StationIDStack next_station = front->GetNextStoppingStation();
1604  bool use_autorefit = front->current_order.IsRefit() && front->current_order.GetRefitCargo() == CT_AUTO_REFIT;
1605  CargoArray consist_capleft;
1606  if (_settings_game.order.improved_load && use_autorefit ?
1607  front->cargo_payment == NULL : (front->current_order.GetLoadType() & OLFB_FULL_LOAD) != 0) {
1608  ReserveConsist(st, front,
1609  (use_autorefit && front->load_unload_ticks != 0) ? &consist_capleft : NULL,
1610  &next_station);
1611  }
1612 
1613  /* We have not waited enough time till the next round of loading/unloading */
1614  if (front->load_unload_ticks != 0) return;
1615 
1616  if (front->type == VEH_TRAIN && (!IsTileType(front->tile, MP_STATION) || GetStationIndex(front->tile) != st->index)) {
1617  /* The train reversed in the station. Take the "easy" way
1618  * out and let the train just leave as it always did. */
1620  front->load_unload_ticks = 1;
1621  return;
1622  }
1623 
1624  int new_load_unload_ticks = 0;
1625  bool dirty_vehicle = false;
1626  bool dirty_station = false;
1627 
1628  bool completely_emptied = true;
1629  bool anything_unloaded = false;
1630  bool anything_loaded = false;
1631  uint32 full_load_amount = 0;
1632  uint32 cargo_not_full = 0;
1633  uint32 cargo_full = 0;
1634  uint32 reservation_left = 0;
1635 
1636  front->cur_speed = 0;
1637 
1638  CargoPayment *payment = front->cargo_payment;
1639 
1640  uint artic_part = 0; // Articulated part we are currently trying to load. (not counting parts without capacity)
1641  for (Vehicle *v = front; v != NULL; v = v->Next()) {
1642  if (v == front || !v->Previous()->HasArticulatedPart()) artic_part = 0;
1643  if (v->cargo_cap == 0) continue;
1644  artic_part++;
1645 
1646  GoodsEntry *ge = &st->goods[v->cargo_type];
1647 
1648  if (HasBit(v->vehicle_flags, VF_CARGO_UNLOADING) && (front->current_order.GetUnloadType() & OUFB_NO_UNLOAD) == 0) {
1649  uint cargo_count = v->cargo.UnloadCount();
1650  uint amount_unloaded = _settings_game.order.gradual_loading ? min(cargo_count, GetLoadAmount(v)) : cargo_count;
1651  bool remaining = false; // Are there cargo entities in this vehicle that can still be unloaded here?
1652 
1653  assert(payment != NULL);
1654  payment->SetCargo(v->cargo_type);
1655 
1656  if (!HasBit(ge->status, GoodsEntry::GES_ACCEPTANCE) && v->cargo.ActionCount(VehicleCargoList::MTA_DELIVER) > 0) {
1657  /* The station does not accept our goods anymore. */
1659  /* Transfer instead of delivering. */
1661  v->cargo.ActionCount(VehicleCargoList::MTA_DELIVER), INVALID_STATION);
1662  } else {
1663  uint new_remaining = v->cargo.RemainingCount() + v->cargo.ActionCount(VehicleCargoList::MTA_DELIVER);
1664  if (v->cargo_cap < new_remaining) {
1665  /* Return some of the reserved cargo to not overload the vehicle. */
1666  v->cargo.Return(new_remaining - v->cargo_cap, &ge->cargo, INVALID_STATION);
1667  }
1668 
1669  /* Keep instead of delivering. This may lead to no cargo being unloaded, so ...*/
1671  v->cargo.ActionCount(VehicleCargoList::MTA_DELIVER));
1672 
1673  /* ... say we unloaded something, otherwise we'll think we didn't unload
1674  * something and we didn't load something, so we must be finished
1675  * at this station. Setting the unloaded means that we will get a
1676  * retry for loading in the next cycle. */
1677  anything_unloaded = true;
1678  }
1679  }
1680 
1681  if (v->cargo.ActionCount(VehicleCargoList::MTA_TRANSFER) > 0) {
1682  /* Mark the station dirty if we transfer, but not if we only deliver. */
1683  dirty_station = true;
1684 
1685  if (!ge->HasRating()) {
1686  /* Upon transfering cargo, make sure the station has a rating. Fake a pickup for the
1687  * first unload to prevent the cargo from quickly decaying after the initial drop. */
1688  ge->time_since_pickup = 0;
1690  }
1691  }
1692 
1693  amount_unloaded = v->cargo.Unload(amount_unloaded, &ge->cargo, payment);
1694  remaining = v->cargo.UnloadCount() > 0;
1695  if (amount_unloaded > 0) {
1696  dirty_vehicle = true;
1697  anything_unloaded = true;
1698  new_load_unload_ticks += amount_unloaded;
1699 
1700  /* Deliver goods to the station */
1701  st->time_since_unload = 0;
1702  }
1703 
1704  if (_settings_game.order.gradual_loading && remaining) {
1705  completely_emptied = false;
1706  } else {
1707  /* We have finished unloading (cargo count == 0) */
1708  ClrBit(v->vehicle_flags, VF_CARGO_UNLOADING);
1709  }
1710 
1711  continue;
1712  }
1713 
1714  /* Do not pick up goods when we have no-load set or loading is stopped. */
1715  if (front->current_order.GetLoadType() & OLFB_NO_LOAD || HasBit(front->vehicle_flags, VF_STOP_LOADING)) continue;
1716 
1717  /* This order has a refit, if this is the first vehicle part carrying cargo and the whole vehicle is empty, try refitting. */
1718  if (front->current_order.IsRefit() && artic_part == 1) {
1719  HandleStationRefit(v, consist_capleft, st, next_station, front->current_order.GetRefitCargo());
1720  ge = &st->goods[v->cargo_type];
1721  }
1722 
1723  /* As we're loading here the following link can carry the full capacity of the vehicle. */
1724  v->refit_cap = v->cargo_cap;
1725 
1726  /* update stats */
1727  int t;
1728  switch (front->type) {
1729  case VEH_TRAIN:
1730  case VEH_SHIP:
1731  t = front->vcache.cached_max_speed;
1732  break;
1733 
1734  case VEH_ROAD:
1735  t = front->vcache.cached_max_speed / 2;
1736  break;
1737 
1738  case VEH_AIRCRAFT:
1739  t = Aircraft::From(front)->GetSpeedOldUnits(); // Convert to old units.
1740  break;
1741 
1742  default: NOT_REACHED();
1743  }
1744 
1745  /* if last speed is 0, we treat that as if no vehicle has ever visited the station. */
1746  ge->last_speed = min(t, 255);
1747  ge->last_age = min(_cur_year - front->build_year, 255);
1748  ge->time_since_pickup = 0;
1749 
1750  assert(v->cargo_cap >= v->cargo.StoredCount());
1751  /* If there's goods waiting at the station, and the vehicle
1752  * has capacity for it, load it on the vehicle. */
1753  uint cap_left = v->cargo_cap - v->cargo.StoredCount();
1754  if (cap_left > 0 && (v->cargo.ActionCount(VehicleCargoList::MTA_LOAD) > 0 || ge->cargo.AvailableCount() > 0)) {
1755  if (v->cargo.StoredCount() == 0) TriggerVehicle(v, VEHICLE_TRIGGER_NEW_CARGO);
1756  if (_settings_game.order.gradual_loading) cap_left = min(cap_left, GetLoadAmount(v));
1757 
1758  uint loaded = ge->cargo.Load(cap_left, &v->cargo, st->xy, next_station);
1759  if (v->cargo.ActionCount(VehicleCargoList::MTA_LOAD) > 0) {
1760  /* Remember if there are reservations left so that we don't stop
1761  * loading before they're loaded. */
1762  SetBit(reservation_left, v->cargo_type);
1763  }
1764 
1765  /* Store whether the maximum possible load amount was loaded or not.*/
1766  if (loaded == cap_left) {
1767  SetBit(full_load_amount, v->cargo_type);
1768  } else {
1769  ClrBit(full_load_amount, v->cargo_type);
1770  }
1771 
1772  /* TODO: Regarding this, when we do gradual loading, we
1773  * should first unload all vehicles and then start
1774  * loading them. Since this will cause
1775  * VEHICLE_TRIGGER_EMPTY to be called at the time when
1776  * the whole vehicle chain is really totally empty, the
1777  * completely_emptied assignment can then be safely
1778  * removed; that's how TTDPatch behaves too. --pasky */
1779  if (loaded > 0) {
1780  completely_emptied = false;
1781  anything_loaded = true;
1782 
1783  st->time_since_load = 0;
1784  st->last_vehicle_type = v->type;
1785 
1786  if (ge->cargo.TotalCount() == 0) {
1787  TriggerStationRandomisation(st, st->xy, SRT_CARGO_TAKEN, v->cargo_type);
1788  TriggerStationAnimation(st, st->xy, SAT_CARGO_TAKEN, v->cargo_type);
1789  AirportAnimationTrigger(st, AAT_STATION_CARGO_TAKEN, v->cargo_type);
1790  }
1791 
1792  new_load_unload_ticks += loaded;
1793 
1794  dirty_vehicle = dirty_station = true;
1795  }
1796  }
1797 
1798  if (v->cargo.StoredCount() >= v->cargo_cap) {
1799  SetBit(cargo_full, v->cargo_type);
1800  } else {
1801  SetBit(cargo_not_full, v->cargo_type);
1802  }
1803  }
1804 
1805  if (anything_loaded || anything_unloaded) {
1806  if (front->type == VEH_TRAIN) {
1808  TriggerStationAnimation(st, front->tile, SAT_TRAIN_LOADS);
1809  }
1810  }
1811 
1812  /* Only set completely_emptied, if we just unloaded all remaining cargo */
1813  completely_emptied &= anything_unloaded;
1814 
1815  if (!anything_unloaded) delete payment;
1816 
1818  if (anything_loaded || anything_unloaded) {
1820  /* The time it takes to load one 'slice' of cargo or passengers depends
1821  * on the vehicle type - the values here are those found in TTDPatch */
1822  const uint gradual_loading_wait_time[] = { 40, 20, 10, 20 };
1823 
1824  new_load_unload_ticks = gradual_loading_wait_time[front->type];
1825  }
1826  /* We loaded less cargo than possible for all cargo types and it's not full
1827  * load and we're not supposed to wait any longer: stop loading. */
1828  if (!anything_unloaded && full_load_amount == 0 && reservation_left == 0 && !(front->current_order.GetLoadType() & OLFB_FULL_LOAD) &&
1829  front->current_order_time >= (uint)max(front->current_order.GetTimetabledWait() - front->lateness_counter, 0)) {
1831  }
1832 
1833  UpdateLoadUnloadTicks(front, st, new_load_unload_ticks);
1834  } else {
1835  UpdateLoadUnloadTicks(front, st, 20); // We need the ticks for link refreshing.
1836  bool finished_loading = true;
1837  if (front->current_order.GetLoadType() & OLFB_FULL_LOAD) {
1838  if (front->current_order.GetLoadType() == OLF_FULL_LOAD_ANY) {
1839  /* if the aircraft carries passengers and is NOT full, then
1840  * continue loading, no matter how much mail is in */
1841  if ((front->type == VEH_AIRCRAFT && IsCargoInClass(front->cargo_type, CC_PASSENGERS) && front->cargo_cap > front->cargo.StoredCount()) ||
1842  (cargo_not_full && (cargo_full & ~cargo_not_full) == 0)) { // There are still non-full cargoes
1843  finished_loading = false;
1844  }
1845  } else if (cargo_not_full != 0) {
1846  finished_loading = false;
1847  }
1848 
1849  /* Refresh next hop stats if we're full loading to make the links
1850  * known to the distribution algorithm and allow cargo to be sent
1851  * along them. Otherwise the vehicle could wait for cargo
1852  * indefinitely if it hasn't visited the other links yet, or if the
1853  * links die while it's loading. */
1854  if (!finished_loading) LinkRefresher::Run(front, true, true);
1855  }
1856 
1857  SB(front->vehicle_flags, VF_LOADING_FINISHED, 1, finished_loading);
1858  }
1859 
1860  /* Calculate the loading indicator fill percent and display
1861  * In the Game Menu do not display indicators
1862  * If _settings_client.gui.loading_indicators == 2, show indicators (bool can be promoted to int as 0 or 1 - results in 2 > 0,1 )
1863  * if _settings_client.gui.loading_indicators == 1, _local_company must be the owner or must be a spectator to show ind., so 1 > 0
1864  * if _settings_client.gui.loading_indicators == 0, do not display indicators ... 0 is never greater than anything
1865  */
1866  if (_game_mode != GM_MENU && (_settings_client.gui.loading_indicators > (uint)(front->owner != _local_company && _local_company != COMPANY_SPECTATOR))) {
1867  StringID percent_up_down = STR_NULL;
1868  int percent = CalcPercentVehicleFilled(front, &percent_up_down);
1869  if (front->fill_percent_te_id == INVALID_TE_ID) {
1870  front->fill_percent_te_id = ShowFillingPercent(front->x_pos, front->y_pos, front->z_pos + 20, percent, percent_up_down);
1871  } else {
1872  UpdateFillingPercent(front->fill_percent_te_id, percent, percent_up_down);
1873  }
1874  }
1875 
1876  if (completely_emptied) {
1877  /* Make sure the vehicle is marked dirty, since we need to update the NewGRF
1878  * properties such as weight, power and TE whenever the trigger runs. */
1879  dirty_vehicle = true;
1880  TriggerVehicle(front, VEHICLE_TRIGGER_EMPTY);
1881  }
1882 
1883  if (dirty_vehicle) {
1886  front->MarkDirty();
1887  }
1888  if (dirty_station) {
1889  st->MarkTilesDirty(true);
1890  SetWindowDirty(WC_STATION_VIEW, last_visited);
1891  InvalidateWindowData(WC_STATION_LIST, last_visited);
1892  }
1893 }
1894 
1901 {
1902  /* No vehicle is here... */
1903  if (st->loading_vehicles.empty()) return;
1904 
1905  Vehicle *last_loading = NULL;
1906  std::list<Vehicle *>::iterator iter;
1907 
1908  /* Check if anything will be loaded at all. Otherwise we don't need to reserve either. */
1909  for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end(); ++iter) {
1910  Vehicle *v = *iter;
1911 
1912  if ((v->vehstatus & (VS_STOPPED | VS_CRASHED))) continue;
1913 
1914  assert(v->load_unload_ticks != 0);
1915  if (--v->load_unload_ticks == 0) last_loading = v;
1916  }
1917 
1918  /* We only need to reserve and load/unload up to the last loading vehicle.
1919  * Anything else will be forgotten anyway after returning from this function.
1920  *
1921  * Especially this means we do _not_ need to reserve cargo for a single
1922  * consist in a station which is not allowed to load yet because its
1923  * load_unload_ticks is still not 0.
1924  */
1925  if (last_loading == NULL) return;
1926 
1927  for (iter = st->loading_vehicles.begin(); iter != st->loading_vehicles.end(); ++iter) {
1928  Vehicle *v = *iter;
1929  if (!(v->vehstatus & (VS_STOPPED | VS_CRASHED))) LoadUnloadVehicle(v);
1930  if (v == last_loading) break;
1931  }
1932 
1933  /* Call the production machinery of industries */
1934  const Industry * const *isend = _cargo_delivery_destinations.End();
1935  for (Industry **iid = _cargo_delivery_destinations.Begin(); iid != isend; iid++) {
1937  }
1938  _cargo_delivery_destinations.Clear();
1939 }
1940 
1945 {
1948  AddInflation();
1949  RecomputePrices();
1950  }
1952  HandleEconomyFluctuations();
1953 }
1954 
1955 static void DoAcquireCompany(Company *c)
1956 {
1957  CompanyID ci = c->index;
1958 
1959  CompanyNewsInformation *cni = MallocT<CompanyNewsInformation>(1);
1961 
1962  SetDParam(0, STR_NEWS_COMPANY_MERGER_TITLE);
1963  SetDParam(1, c->bankrupt_value == 0 ? STR_NEWS_MERGER_TAKEOVER_TITLE : STR_NEWS_COMPANY_MERGER_DESCRIPTION);
1964  SetDParamStr(2, cni->company_name);
1966  SetDParam(4, c->bankrupt_value);
1967  AddCompanyNewsItem(STR_MESSAGE_NEWS_FORMAT, cni);
1968  AI::BroadcastNewEvent(new ScriptEventCompanyMerger(ci, _current_company));
1969  Game::NewEvent(new ScriptEventCompanyMerger(ci, _current_company));
1970 
1972 
1973  if (c->bankrupt_value == 0) {
1975  owner->current_loan += c->current_loan;
1976  }
1977 
1978  if (c->is_ai) AI::Stop(c->index);
1979 
1985 
1986  delete c;
1987 }
1988 
1989 extern int GetAmountOwnedBy(const Company *c, Owner owner);
1990 
2000 CommandCost CmdBuyShareInCompany(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
2001 {
2003  CompanyID target_company = (CompanyID)p1;
2004  Company *c = Company::GetIfValid(target_company);
2005 
2006  /* Check if buying shares is allowed (protection against modified clients)
2007  * Cannot buy own shares */
2008  if (c == NULL || !_settings_game.economy.allow_shares || _current_company == target_company) return CMD_ERROR;
2009 
2010  /* Protect new companies from hostile takeovers */
2011  if (_cur_year - c->inaugurated_year < 6) return_cmd_error(STR_ERROR_PROTECTED);
2012 
2013  /* Those lines are here for network-protection (clients can be slow) */
2014  if (GetAmountOwnedBy(c, COMPANY_SPECTATOR) == 0) return cost;
2015 
2016  if (GetAmountOwnedBy(c, COMPANY_SPECTATOR) == 1) {
2017  if (!c->is_ai) return cost; // We can not buy out a real company (temporarily). TODO: well, enable it obviously.
2018 
2019  if (GetAmountOwnedBy(c, _current_company) == 3 && !MayCompanyTakeOver(_current_company, target_company)) return_cmd_error(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME);
2020  }
2021 
2022 
2023  cost.AddCost(CalculateCompanyValue(c) >> 2);
2024  if (flags & DC_EXEC) {
2025  OwnerByte *b = c->share_owners;
2026 
2027  while (*b != COMPANY_SPECTATOR) b++; // share owners is guaranteed to contain at least one COMPANY_SPECTATOR
2028  *b = _current_company;
2029 
2030  for (int i = 0; c->share_owners[i] == _current_company;) {
2031  if (++i == 4) {
2032  c->bankrupt_value = 0;
2033  DoAcquireCompany(c);
2034  break;
2035  }
2036  }
2037  InvalidateWindowData(WC_COMPANY, target_company);
2038  CompanyAdminUpdate(c);
2039  }
2040  return cost;
2041 }
2042 
2052 CommandCost CmdSellShareInCompany(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
2053 {
2054  CompanyID target_company = (CompanyID)p1;
2055  Company *c = Company::GetIfValid(target_company);
2056 
2057  /* Cannot sell own shares */
2058  if (c == NULL || _current_company == target_company) return CMD_ERROR;
2059 
2060  /* Check if selling shares is allowed (protection against modified clients).
2061  * However, we must sell shares of companies being closed down. */
2062  if (!_settings_game.economy.allow_shares && !(flags & DC_BANKRUPT)) return CMD_ERROR;
2063 
2064  /* Those lines are here for network-protection (clients can be slow) */
2065  if (GetAmountOwnedBy(c, _current_company) == 0) return CommandCost();
2066 
2067  /* adjust it a little to make it less profitable to sell and buy */
2068  Money cost = CalculateCompanyValue(c) >> 2;
2069  cost = -(cost - (cost >> 7));
2070 
2071  if (flags & DC_EXEC) {
2072  OwnerByte *b = c->share_owners;
2073  while (*b != _current_company) b++; // share owners is guaranteed to contain company
2074  *b = COMPANY_SPECTATOR;
2075  InvalidateWindowData(WC_COMPANY, target_company);
2076  CompanyAdminUpdate(c);
2077  }
2078  return CommandCost(EXPENSES_OTHER, cost);
2079 }
2080 
2093 CommandCost CmdBuyCompany(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
2094 {
2095  CompanyID target_company = (CompanyID)p1;
2096  Company *c = Company::GetIfValid(target_company);
2097  if (c == NULL) return CMD_ERROR;
2098 
2099  /* Disable takeovers when not asked */
2100  if (!HasBit(c->bankrupt_asked, _current_company)) return CMD_ERROR;
2101 
2102  /* Disable taking over the local company in single player */
2103  if (!_networking && _local_company == c->index) return CMD_ERROR;
2104 
2105  /* Do not allow companies to take over themselves */
2106  if (target_company == _current_company) return CMD_ERROR;
2107 
2108  /* Disable taking over when not allowed. */
2109  if (!MayCompanyTakeOver(_current_company, target_company)) return CMD_ERROR;
2110 
2111  /* Get the cost here as the company is deleted in DoAcquireCompany. */
2112  CommandCost cost(EXPENSES_OTHER, c->bankrupt_value);
2113 
2114  if (flags & DC_EXEC) {
2115  DoAcquireCompany(c);
2116  }
2117  return cost;
2118 }