OpenTTD Source 20261112-master-gbcbec5e63f
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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
6 */
7
9
10#include "stdafx.h"
11#include <ranges>
12#include "company_func.h"
13#include "command_func.h"
14#include "industry.h"
15#include "town.h"
16#include "news_func.h"
17#include "network/network.h"
19#include "ai/ai.hpp"
20#include "aircraft.h"
21#include "train.h"
22#include "newgrf_engine.h"
23#include "engine_base.h"
24#include "ground_vehicle.hpp"
25#include "newgrf_cargo.h"
26#include "newgrf_sound.h"
28#include "newgrf_station.h"
29#include "newgrf_airporttiles.h"
30#include "newgrf_roadstop.h"
31#include "object.h"
32#include "strings_func.h"
33#include "vehicle_func.h"
34#include "sound_func.h"
35#include "autoreplace_func.h"
36#include "company_gui.h"
37#include "signs_base.h"
38#include "subsidy_base.h"
39#include "subsidy_func.h"
40#include "station_base.h"
41#include "station_func.h"
42#include "vehicle_gui.h"
43#include "waypoint_base.h"
44#include "economy_base.h"
45#include "core/pool_func.hpp"
46#include "core/backup_type.hpp"
48#include "cargo_type.h"
49#include "water.h"
50#include "game/game.hpp"
51#include "cargomonitor.h"
52#include "goal_base.h"
53#include "story_base.h"
54#include "linkgraph/refresh.h"
55#include "company_cmd.h"
56#include "economy_cmd.h"
57#include "vehicle_cmd.h"
58#include "script/api/script_event_types.hpp"
59#include "timer/timer.h"
62
63#include "table/strings.h"
64#include "table/pricebase.h"
65
66#include "safeguards.h"
67
68
69/* Initialize the cargo payment-pool */
72
73
84static inline int32_t BigMulS(const int32_t a, const int32_t b, const uint8_t shift)
85{
86 return (int32_t)((int64_t)a * (int64_t)b >> shift);
87}
88
89typedef std::vector<Industry *> SmallIndustryList;
90
95 ScoreInfo(100, 120), // ScoreID::Vehicles
96 ScoreInfo(100, 80), // ScoreID::Stations
97 ScoreInfo(100, 10000), // ScoreID::MinProfit
98 ScoreInfo(50, 50000), // ScoreID::MinIncome
99 ScoreInfo(100, 100000), // ScoreID::MaxIncome
100 ScoreInfo(400, 40000), // ScoreID::Delivered
101 ScoreInfo(50, 8), // ScoreID::Cargo
102 ScoreInfo(50, 10000000), // ScoreID::Money
103 ScoreInfo(50, 250000), // ScoreID::Loan
104 ScoreInfo(0, 0), // ScoreID::Total
105};
106
108Economy _economy;
110static PriceMultipliers _price_base_multiplier;
111
119{
120 Owner owner = c->index;
121
122 uint num = 0;
123
124 for (const Station *st : Station::Iterate()) {
125 if (st->owner == owner) num += st->facilities.Count();
126 }
127
128 Money value = num * _price[Price::StationValue] * 25;
129
130 for (const Vehicle *v : Vehicle::Iterate()) {
131 if (v->owner != owner) continue;
132
133 if (v->type == VehicleType::Train ||
134 v->type == VehicleType::Road ||
135 (v->type == VehicleType::Aircraft && Aircraft::From(v)->IsNormalAircraft()) ||
136 v->type == VehicleType::Ship) {
137 value += v->value * 3 >> 1;
138 }
139 }
140
141 return value;
142}
143
153Money CalculateCompanyValue(const Company *c, bool including_loan)
154{
155 Money value = CalculateCompanyAssetValue(c);
156
157 /* Add real money value */
158 if (including_loan) value -= c->current_loan;
159 value += c->money;
160
161 return std::max<Money>(value, 1);
162}
163
181{
182 Money value = CalculateCompanyAssetValue(c);
183
184 value += c->current_loan;
185 /* Negative balance is basically a loan. */
186 if (c->money < 0) {
187 value += -c->money;
188 }
189
190 for (int quarter = 0; quarter < 4; quarter++) {
191 value += std::max<Money>(c->old_economy[quarter].income + c->old_economy[quarter].expenses, 0) * 2;
192 }
193
194 return std::max<Money>(value, 1);
195}
196
206{
207 Owner owner = c->index;
208 int score = 0;
209
210 _score_part[owner].fill(0);
211
212 /* Count vehicles */
213 {
214 Money min_profit = 0;
215 bool min_profit_first = true;
216 uint num = 0;
217
218 for (const Vehicle *v : Vehicle::Iterate()) {
219 if (v->owner != owner) continue;
220 if (IsCompanyBuildableVehicleType(v->type) && v->IsPrimaryVehicle()) {
221 if (v->profit_last_year > 0) num++; // For the vehicle score only count profitable vehicles
222 if (v->economy_age > VEHICLE_PROFIT_MIN_AGE) {
223 /* Find the vehicle with the lowest amount of profit */
224 if (min_profit_first || min_profit > v->profit_last_year) {
225 min_profit = v->profit_last_year;
226 min_profit_first = false;
227 }
228 }
229 }
230 }
231
232 min_profit >>= 8; // remove the fract part
233
234 _score_part[owner][ScoreID::Vehicles] = num;
235 /* Don't allow negative min_profit to show */
236 if (min_profit > 0) {
237 _score_part[owner][ScoreID::MinProfit] = min_profit;
238 }
239 }
240
241 /* Count stations */
242 {
243 uint num = 0;
244 for (const Station *st : Station::Iterate()) {
245 /* Only count stations that are actually serviced */
246 if (st->owner == owner && (st->time_since_load <= 20 || st->time_since_unload <= 20)) num += st->facilities.Count();
247 }
248 _score_part[owner][ScoreID::Stations] = num;
249 }
250
251 /* Generate statistics depending on recent income statistics */
252 {
253 int numec = std::min<uint>(c->num_valid_stat_ent, 12u);
254 if (numec != 0) {
255 auto [min_income, max_income] = std::ranges::minmax(c->old_economy | std::views::take(numec) | std::views::transform([](const auto &ce) { return ce.income + ce.expenses; }));
256
257 if (min_income > 0) _score_part[owner][ScoreID::MinIncome] = min_income;
258 _score_part[owner][ScoreID::MaxIncome] = max_income;
259 }
260 }
261
262 /* Generate score depending on amount of transported cargo */
263 {
264 int numec = std::min<uint>(c->num_valid_stat_ent, 4u);
265 if (numec != 0) {
266 OverflowSafeInt64 total_delivered = 0;
267 for (auto &ce : c->old_economy | std::views::take(numec)) total_delivered += ce.delivered_cargo.GetSum<OverflowSafeInt64>();
268
269 _score_part[owner][ScoreID::Delivered] = total_delivered;
270 }
271 }
272
273 /* Generate score for variety of cargo */
274 {
275 _score_part[owner][ScoreID::Cargo] = c->old_economy[0].delivered_cargo.GetCount();
276 }
277
278 /* Generate score for company's money */
279 {
280 if (c->money > 0) {
281 _score_part[owner][ScoreID::Money] = c->money;
282 }
283 }
284
285 /* Generate score for loan */
286 {
287 _score_part[owner][ScoreID::Loan] = _score_info[ScoreID::Loan].needed - c->current_loan;
288 }
289
290 /* Now we calculate the score for each item.. */
291 {
292 int total_score = 0;
293 int s;
294 score = 0;
295 for (ScoreID i : EnumRange(ScoreID::End)) {
296 /* Skip the total */
297 if (i == ScoreID::Total) continue;
298 /* Check the score */
299 s = Clamp<int64_t>(_score_part[owner][i], 0, _score_info[i].needed) * _score_info[i].score / _score_info[i].needed;
300 score += s;
301 total_score += _score_info[i].score;
302 }
303
304 _score_part[owner][ScoreID::Total] = score;
305
306 /* We always want the score scaled to SCORE_MAX (1000) */
307 if (total_score != SCORE_MAX) score = score * SCORE_MAX / total_score;
308 }
309
310 if (update) {
311 c->old_economy[0].performance_history = score;
313 c->old_economy[0].company_value = CalculateCompanyValue(c);
314 }
315
316 SetWindowDirty(WindowClass::PerformanceDetail, 0);
317 return score;
318}
319
325void ChangeOwnershipOfCompanyItems(Owner old_owner, Owner new_owner)
326{
327 /* We need to set _current_company to old_owner before we try to move
328 * the client. This is needed as it needs to know whether "you" really
329 * are the current local company. */
330 AutoRestoreBackup cur_company(_current_company, old_owner);
331 /* In all cases, make spectators of clients connected to that company */
333 if (old_owner == _local_company) {
334 /* Single player cheated to AI company.
335 * There are no spectators in singleplayer mode, so we must pick some other company. */
336 assert(!_networking);
338 for (const Company *c : Company::Iterate()) {
339 if (c->index != old_owner) {
340 SetLocalCompany(c->index);
341 break;
342 }
343 }
344 cur_company2.Restore();
345 assert(old_owner != _local_company);
346 }
347
348 assert(old_owner != new_owner);
349
350 /* Temporarily increase the company's money, to be sure that
351 * removing their property doesn't fail because of lack of money.
352 * Not too drastically though, because it could overflow */
353 if (new_owner == INVALID_OWNER) {
354 Company::Get(old_owner)->money = UINT64_MAX >> 2; // jackpot ;p
355 }
356
357 for (Subsidy *s : Subsidy::Iterate()) {
358 if (s->awarded == old_owner) {
359 if (new_owner == INVALID_OWNER) {
360 delete s;
361 } else {
362 s->awarded = new_owner;
363 }
364 }
365 }
367
368 /* Take care of rating and transport rights in towns */
369 for (Town *t : Town::Iterate()) {
370 /* If a company takes over, give the ratings to that company. */
371 if (new_owner != INVALID_OWNER) {
372 if (t->have_ratings.Test(old_owner)) {
373 if (t->have_ratings.Test(new_owner)) {
374 /* use max of the two ratings. */
375 t->ratings[new_owner] = std::max(t->ratings[new_owner], t->ratings[old_owner]);
376 } else {
377 t->have_ratings.Set(new_owner);
378 t->ratings[new_owner] = t->ratings[old_owner];
379 }
380 }
381 t->unwanted[new_owner] = std::max(t->unwanted[old_owner], t->unwanted[new_owner]);
382 }
383
384 /* Reset the ratings for the old owner */
385 t->ratings[old_owner] = RATING_INITIAL;
386 t->have_ratings.Reset(old_owner);
387 t->unwanted[old_owner] = 0;
388
389 /* Transfer exclusive rights */
390 if (t->exclusive_counter > 0 && t->exclusivity == old_owner) {
391 if (new_owner != INVALID_OWNER) {
392 t->exclusivity = new_owner;
393 } else {
394 t->exclusive_counter = 0;
395 t->exclusivity = CompanyID::Invalid();
396 }
397 }
398 }
399
400 {
401 for (Vehicle *v : Vehicle::Iterate()) {
402 if (v->owner == old_owner && IsCompanyBuildableVehicleType(v->type)) {
403 if (new_owner == INVALID_OWNER) {
404 if (v->Previous() == nullptr) delete v;
405 } else {
406 if (v->IsEngineCountable()) GroupStatistics::CountEngine(v, -1);
407 if (v->IsPrimaryVehicle()) GroupStatistics::CountVehicle(v, -1);
408 }
409 }
410 }
411 }
412
413 /* In all cases clear replace engine rules.
414 * Even if it was copied, it could interfere with new owner's rules */
416
417 if (new_owner == INVALID_OWNER) {
418 RemoveAllGroupsForCompany(old_owner);
419 } else {
420 Company *c = Company::Get(new_owner);
421 for (Group *g : Group::Iterate()) {
422 if (g->owner == old_owner) {
423 g->owner = new_owner;
424 g->number = c->freegroups.UseID(c->freegroups.NextID());
425 }
426 }
427 }
428
429 {
430 Company *new_company = new_owner == INVALID_OWNER ? nullptr : Company::Get(new_owner);
431
432 /* Override company settings to new company defaults in case we need to convert them.
433 * This is required as the CmdChangeServiceInt doesn't copy the supplied value when it is non-custom
434 */
435 if (new_owner != INVALID_OWNER) {
436 Company *old_company = Company::Get(old_owner);
437
439 old_company->settings.vehicle.servint_trains = new_company->settings.vehicle.servint_trains;
441 old_company->settings.vehicle.servint_ships = new_company->settings.vehicle.servint_ships;
443 }
444
445 for (Vehicle *v : Vehicle::Iterate()) {
446 if (v->owner == old_owner && IsCompanyBuildableVehicleType(v->type)) {
447 assert(new_owner != INVALID_OWNER);
448
449 /* Correct default values of interval settings while maintaining custom set ones.
450 * This prevents invalid values on mismatching company defaults being accepted.
451 */
452 if (!v->ServiceIntervalIsCustom()) {
453 /* Technically, passing the interval is not needed as the command will query the default value itself.
454 * However, do not rely on that behaviour.
455 */
456 int interval = CompanyServiceInterval(new_company, v->type);
457 Command<Commands::ChangeServiceInterval>::Do({DoCommandFlag::Execute, DoCommandFlag::Bankrupt}, v->index, interval, false, new_company->settings.vehicle.servint_ispercent);
458 }
459
460 v->owner = new_owner;
461
462 /* Owner changes, clear cache */
463 v->colourmap = PAL_NONE;
464 v->InvalidateNewGRFCache();
465
466 if (v->IsEngineCountable()) {
468 }
469 if (v->IsPrimaryVehicle()) {
471 auto &unitidgen = new_company->freeunits[v->type];
472 v->unitnumber = unitidgen.UseID(unitidgen.NextID());
473 }
474 }
475 }
476
477 if (new_owner != INVALID_OWNER) GroupStatistics::UpdateAutoreplace(new_owner);
478 }
479
480 /* Change ownership of tiles */
481 {
482 for (const auto tile : Map::Iterate()) {
483 ChangeTileOwner(tile, old_owner, new_owner);
484 }
485
486 if (new_owner != INVALID_OWNER) {
487 /* Update all signals because there can be new segment that was owned by two companies
488 * and signals were not propagated
489 * Similar with crossings - it is needed to bar crossings that weren't before
490 * because of different owner of crossing and approaching train */
491 for (const auto tile : Map::Iterate()) {
492 if (IsTileType(tile, TileType::Railway) && IsTileOwner(tile, new_owner) && HasSignals(tile)) {
493 for (Track track : GetTrackBits(tile)) {
494 if (IsSignalPresent(tile, SignalOnTrack(track))) AddTrackToSignalBuffer(tile, track, new_owner);
495 }
496 } else if (IsLevelCrossingTile(tile) && IsTileOwner(tile, new_owner)) {
498 }
499 }
500 }
501
502 /* update signals in buffer */
504 }
505
506 /* Add airport infrastructure count of the old company to the new one. */
507 if (new_owner != INVALID_OWNER) Company::Get(new_owner)->infrastructure.airport += Company::Get(old_owner)->infrastructure.airport;
508
509 /* convert owner of stations (including deleted ones, but excluding buoys) */
510 for (Station *st : Station::Iterate()) {
511 if (st->owner == old_owner) {
512 /* if a company goes bankrupt, set owner to OWNER_NONE so the sign doesn't disappear immediately
513 * also, drawing station window would cause reading invalid company's colour */
514 st->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
515 }
516 }
517
518 /* do the same for waypoints (we need to do this here so deleted waypoints are converted too) */
519 for (Waypoint *wp : Waypoint::Iterate()) {
520 if (wp->owner == old_owner) {
521 wp->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
522 }
523 }
524
525 for (Sign *si : Sign::Iterate()) {
526 if (si->owner == old_owner) si->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
527 }
528
529 /* Remove Game Script created Goals, CargoMonitors and Story pages. */
530 for (Goal *g : Goal::Iterate()) {
531 if (g->company == old_owner) delete g;
532 }
533
536
537 for (StoryPage *sp : StoryPage::Iterate()) {
538 if (sp->company == old_owner) delete sp;
539 }
540
541 /* Change colour of existing windows */
542 if (new_owner != INVALID_OWNER) ChangeWindowOwner(old_owner, new_owner);
543
545}
546
552{
553 /* If "Infinite money" setting is on, companies should not go bankrupt. */
554 if (_settings_game.difficulty.infinite_money) return;
555
556 /* If the company has money again, it does not go bankrupt */
557 if (c->money - c->current_loan >= -c->GetMaxLoan()) {
558 int previous_months_of_bankruptcy = CeilDiv(c->months_of_bankruptcy, 3);
561 if (previous_months_of_bankruptcy != 0) CompanyAdminUpdate(c);
562 return;
563 }
564
566
567 switch (c->months_of_bankruptcy) {
568 /* All the boring cases (months) with a bad balance where no action is taken */
569 case 0:
570 case 1:
571 case 2:
572 case 3:
573
574 case 5:
575 case 6:
576
577 case 8:
578 case 9:
579 break;
580
581 /* Warn about bankruptcy after 3 months */
582 case 4: {
583 auto cni = std::make_unique<CompanyNewsInformation>(STR_NEWS_COMPANY_IN_TROUBLE_TITLE, c);
584 EncodedString headline = GetEncodedString(STR_NEWS_COMPANY_IN_TROUBLE_DESCRIPTION, cni->company_name);
585 AddCompanyNewsItem(std::move(headline), std::move(cni));
586 AI::BroadcastNewEvent(new ScriptEventCompanyInTrouble(c->index));
587 Game::NewEvent(new ScriptEventCompanyInTrouble(c->index));
588 break;
589 }
590
591 /* Offer company for sale after 6 months */
592 case 7: {
593 /* Don't consider the loan */
594 Money val = CalculateCompanyValue(c, false);
595
596 c->bankrupt_value = val;
597 c->bankrupt_asked = CompanyMask{}.Set(c->index); // Don't ask the owner
598 c->bankrupt_timeout = 0;
599
600 /* The company assets should always have some value */
601 assert(c->bankrupt_value > 0);
602 break;
603 }
604
605 /* Bankrupt company after 6 months (if the company has no value) or latest
606 * after 9 months (if it still had value after 6 months) */
607 default:
608 case 10: {
609 if (!_networking && _local_company == c->index) {
610 /* If we are in singleplayer mode, leave the company playing. Eg. there
611 * is no THE-END, otherwise mark the client as spectator to make sure
612 * they are no longer in control of this company. However... when you
613 * join another company (cheat) the "unowned" company can bankrupt. */
614 c->bankrupt_asked.Set();
615 break;
616 }
617
618 /* Actually remove the company, but not when we're a network client.
619 * In case of network clients we will be getting a command from the
620 * server. It is done in this way as we are called from the
621 * StateGameLoop which can't change the current company, and thus
622 * updating the local company triggers an assert later on. In the
623 * case of a network game the command will be processed at a time
624 * that changing the current company is okay. In case of single
625 * player we are sure (the above check) that we are not the local
626 * company and thus we won't be moved. */
628 Command<Commands::CompanyControl>::Post(CompanyCtrlAction::Delete, c->index, CompanyRemoveReason::Bankrupt, ClientID::Invalid);
629 return;
630 }
631 break;
632 }
633 }
634
636}
637
643{
644 /* Check for bankruptcy each month */
645 for (Company *c : Company::Iterate()) {
647 }
648
649 /* Pay Infrastructure Maintenance, if enabled */
650 if (_settings_game.economy.infrastructure_maintenance) {
651 /* Improved monthly infrastructure costs. */
652 for (const Company *c : Company::Iterate()) {
654 uint32_t rail_total = c->infrastructure.GetRailTotal();
655 for (RailType rt : EnumRange(RAILTYPE_END)) {
656 if (c->infrastructure.rail[rt] != 0) cost.AddCost(RailMaintenanceCost(rt, c->infrastructure.rail[rt], rail_total));
657 }
658 cost.AddCost(SignalMaintenanceCost(c->infrastructure.signal));
659 uint32_t road_total = c->infrastructure.GetRoadTotal();
660 uint32_t tram_total = c->infrastructure.GetTramTotal();
661 for (RoadType rt : EnumRange(ROADTYPE_END)) {
662 if (c->infrastructure.road[rt] != 0) cost.AddCost(RoadMaintenanceCost(rt, c->infrastructure.road[rt], RoadTypeIsRoad(rt) ? road_total : tram_total));
663 }
664 cost.AddCost(CanalMaintenanceCost(c->infrastructure.water));
665 cost.AddCost(StationMaintenanceCost(c->infrastructure.station));
666 cost.AddCost(AirportMaintenanceCost(c->index));
667
668 SubtractMoneyFromCompany(c->index, cost);
669 }
670 }
671
672 /* Only run the economic statistics and update company stats every 3rd economy month (1st of quarter). */
673 if (!HasBit(1 << 0 | 1 << 3 | 1 << 6 | 1 << 9, TimerGameEconomy::month)) return;
674
675 for (Company *c : Company::Iterate()) {
676 /* Drop the oldest history off the end */
677 std::copy_backward(c->old_economy.data(), c->old_economy.data() + MAX_HISTORY_QUARTERS - 1, c->old_economy.data() + MAX_HISTORY_QUARTERS);
678 c->old_economy[0] = c->cur_economy;
679 c->cur_economy = {};
680
681 if (c->num_valid_stat_ent != MAX_HISTORY_QUARTERS) c->num_valid_stat_ent++;
682
684 if (c->block_preview != 0) c->block_preview--;
685 }
686
687 SetWindowDirty(WindowClass::IncomeGraph, 0);
688 SetWindowDirty(WindowClass::OperatingProfitGraph, 0);
689 SetWindowDirty(WindowClass::DeliveredCargoGraph, 0);
690 SetWindowDirty(WindowClass::PerformanceGraph, 0);
691 SetWindowDirty(WindowClass::CompanyValueGraph, 0);
692 SetWindowDirty(WindowClass::CompanyLeague, 0);
693}
694
700bool AddInflation(bool check_year)
701{
702 /* The cargo payment inflation differs from the normal inflation, so the
703 * relative amount of money you make with a transport decreases slowly over
704 * the 170 years. After a few hundred years we reach a level in which the
705 * games will become unplayable as the maximum income will be less than
706 * the minimum running cost.
707 *
708 * Furthermore there are a lot of inflation related overflows all over the
709 * place. Solving them is hardly possible because inflation will always
710 * reach the overflow threshold some day. So we'll just perform the
711 * inflation mechanism during the first 170 years (the amount of years that
712 * one had in the original TTD) and stop doing the inflation after that
713 * because it only causes problems that can't be solved nicely and the
714 * inflation doesn't add anything after that either; it even makes playing
715 * it impossible due to the diverging cost and income rates.
716 */
718
719 if (_economy.inflation_prices == MAX_INFLATION || _economy.inflation_payment == MAX_INFLATION) return true;
720
721 /* Approximation for (100 + infl_amount)% ** (1 / 12) - 100%
722 * scaled by 65536
723 * 12 -> months per year
724 * This is only a good approximation for small values
725 */
726 _economy.inflation_prices += (_economy.inflation_prices * _economy.infl_amount * 54) >> 16;
727 _economy.inflation_payment += (_economy.inflation_payment * _economy.infl_amount_pr * 54) >> 16;
728
729 if (_economy.inflation_prices > MAX_INFLATION) _economy.inflation_prices = MAX_INFLATION;
730 if (_economy.inflation_payment > MAX_INFLATION) _economy.inflation_payment = MAX_INFLATION;
731
732 return false;
733}
734
739{
740 /* Setup maximum loan as a rounded down multiple of LOAN_INTERVAL. */
741 _economy.max_loan = ((uint64_t)_settings_game.difficulty.max_loan * _economy.inflation_prices >> 16) / LOAN_INTERVAL * LOAN_INTERVAL;
742
743 /* Setup price bases */
744 for (Price i : EnumRange(Price::End)) {
745 Money price = _price_base_specs[i].start_price;
746
747 /* Apply difficulty settings */
748 uint mod = 1;
749 switch (_price_base_specs[i].category) {
751 mod = _settings_game.difficulty.vehicle_costs;
752 break;
753
755 mod = _settings_game.difficulty.construction_cost;
756 break;
757
758 default: break;
759 }
760 switch (mod) {
761 case 0: price *= 6; break;
762 case 1: price *= 8; break; // normalised to 1 below
763 case 2: price *= 9; break;
764 default: NOT_REACHED();
765 }
766
767 /* Apply inflation */
768 price = (int64_t)price * _economy.inflation_prices;
769
770 /* Apply newgrf modifiers, remove fractional part of inflation, and normalise on medium difficulty. */
771 int shift = _price_base_multiplier[i] - 16 - 3;
772 if (shift >= 0) {
773 price <<= shift;
774 } else {
775 price >>= -shift;
776 }
777
778 /* Make sure the price does not get reduced to zero.
779 * Zero breaks quite a few commands that use a zero
780 * cost to see whether something got changed or not
781 * and based on that cause an error. When the price
782 * is zero that fails even when things are done. */
783 if (price == 0) {
784 price = Clamp(_price_base_specs[i].start_price, -1, 1);
785 /* No base price should be zero, but be sure. */
786 assert(price != 0);
787 }
788 /* Store value */
789 _price[i] = price;
790 }
791
792 /* Setup cargo payment */
793 for (CargoSpec *cs : CargoSpec::Iterate()) {
794 cs->current_payment = (cs->initial_payment * (int64_t)_economy.inflation_payment) >> 16;
795 }
796
797 SetWindowClassesDirty(WindowClass::BuildVehicle);
798 SetWindowClassesDirty(WindowClass::ReplaceVehicle);
799 SetWindowClassesDirty(WindowClass::VehicleDetails);
800 SetWindowClassesDirty(WindowClass::CompanyInfrastructure);
801 InvalidateWindowData(WindowClass::CargoPaymentRatesGraph, 0);
802}
803
806{
807 for (const Company *c : Company::Iterate()) {
808 /* Over a year the paid interest should be "loan * interest percentage",
809 * but... as that number is likely not dividable by 12 (pay each month),
810 * one needs to account for that in the monthly fee calculations.
811 *
812 * To easily calculate what one should pay "this" month, you calculate
813 * what (total) should have been paid up to this month and you subtract
814 * whatever has been paid in the previous months. This will mean one month
815 * it'll be a bit more and the other it'll be a bit less than the average
816 * monthly fee, but on average it will be exact.
817 *
818 * In order to prevent cheating or abuse (just not paying interest by not
819 * taking a loan) we make companies pay interest on negative cash as well,
820 * except if infinite money is enabled.
821 */
822 Money yearly_fee = c->current_loan * _economy.interest_rate / 100;
823 Money available_money = GetAvailableMoney(c->index);
824 if (available_money < 0) {
825 yearly_fee += -available_money * _economy.interest_rate / 100;
826 }
827 Money up_to_previous_month = yearly_fee * TimerGameEconomy::month / 12;
828 Money up_to_this_month = yearly_fee * (TimerGameEconomy::month + 1) / 12;
829
830 SubtractMoneyFromCompany(c->index, CommandCost(ExpensesType::LoanInterest, up_to_this_month - up_to_previous_month));
831
833 }
834}
835
836static void HandleEconomyFluctuations()
837{
838 if (_settings_game.difficulty.economy != 0) {
839 /* When economy is Fluctuating, decrease counter */
840 _economy.fluct--;
841 } else if (EconomyIsInRecession()) {
842 /* When it's Steady and we are in recession, end it now */
843 _economy.fluct = -12;
844 } else {
845 /* No need to do anything else in other cases */
846 return;
847 }
848
849 if (_economy.fluct == 0) {
850 _economy.fluct = -(int)GB(Random(), 0, 2);
851 AddNewsItem(GetEncodedString(STR_NEWS_BEGIN_OF_RECESSION), NewsType::Economy, NewsStyle::Normal, {});
852 } else if (_economy.fluct == -12) {
853 _economy.fluct = GB(Random(), 0, 8) + 312;
854 AddNewsItem(GetEncodedString(STR_NEWS_END_OF_RECESSION), NewsType::Economy, NewsStyle::Normal, {});
855 }
856}
857
858
863{
864 _price_base_multiplier.fill(0);
865}
866
874void SetPriceBaseMultiplier(Price price, int factor)
875{
876 assert(price < Price::End);
877 _price_base_multiplier[price] = Clamp(factor, MIN_PRICE_MODIFIER, MAX_PRICE_MODIFIER);
878}
879
884void StartupIndustryDailyChanges(bool init_counter)
885{
886 uint map_size = Map::LogX() + Map::LogY();
887 /* After getting map size, it needs to be scaled appropriately and divided by 31,
888 * which stands for the days in a month.
889 * Using just 31 will make it so that a monthly reset (based on the real number of days of that month)
890 * would not be needed.
891 * Since it is based on "fractional parts", the leftover days will not make much of a difference
892 * on the overall total number of changes performed */
893 _economy.industry_daily_increment = (1 << map_size) / 31;
894
895 if (init_counter) {
896 /* A new game or a savegame from an older version will require the counter to be initialized */
897 _economy.industry_daily_change_counter = 0;
898 }
899}
900
901void StartupEconomy()
902{
903 _economy.interest_rate = _settings_game.difficulty.initial_interest;
904 _economy.infl_amount = _settings_game.difficulty.initial_interest;
905 _economy.infl_amount_pr = std::max(0, _settings_game.difficulty.initial_interest - 1);
906 _economy.fluct = GB(Random(), 0, 8) + 168;
907
908 if (_settings_game.economy.inflation) {
909 /* Apply inflation that happened before our game start year. */
911 for (int i = 0; i < months; i++) {
912 AddInflation(false);
913 }
914 }
915
916 /* Set up prices */
918
919 StartupIndustryDailyChanges(true); // As we are starting a new game, initialize the counter too
920
921}
922
927{
928 _economy.inflation_prices = _economy.inflation_payment = 1 << 16;
931}
932
941Money GetPrice(Price index, uint cost_factor, const GRFFile *grf_file, int shift)
942{
943 if (index >= Price::End) return 0;
944
945 Money cost = _price[index] * cost_factor;
946 if (grf_file != nullptr) shift += grf_file->price_base_multipliers[index];
947
948 if (shift >= 0) {
949 cost <<= shift;
950 } else {
951 cost >>= -shift;
952 }
953
954 return cost;
955}
956
957Money GetTransportedGoodsIncome(uint num_pieces, uint dist, uint16_t transit_periods, CargoType cargo_type)
958{
959 const CargoSpec *cs = CargoSpec::Get(cargo_type);
960 if (!cs->IsValid()) {
961 /* User changed newgrfs and some vehicle still carries some cargo which is no longer available. */
962 return 0;
963 }
964
965 /* Scale transit periods according to the game setting. We also pass this scaled value to the NewGRF callback. */
966 transit_periods = ScaleByPercentage<uint16_t, uint32_t>(transit_periods, _settings_game.economy.cargo_aging_rate);
967
968 /* Use callback to calculate cargo profit, if available */
970 uint32_t var18 = ClampTo<uint16_t>(dist) | (ClampTo<uint8_t>(num_pieces) << 16) | (ClampTo<uint8_t>(transit_periods) << 24);
971 uint16_t callback = GetCargoCallback(CBID_CARGO_PROFIT_CALC, 0, var18, cs);
972 if (callback != CALLBACK_FAILED) {
973 int result = GB(callback, 0, 14);
974
975 /* Simulate a 15 bit signed value */
976 if (HasBit(callback, 14)) result -= 0x4000;
977
978 /* "The result should be a signed multiplier that gets multiplied
979 * by the amount of cargo moved and the price factor, then gets
980 * divided by 8192." */
981 return result * num_pieces * cs->current_payment / 8192;
982 }
983 }
984
985 static const int MIN_TIME_FACTOR = 31;
986 static const int MAX_TIME_FACTOR = 255;
987 static const int TIME_FACTOR_FRAC_BITS = 4;
988 static const int TIME_FACTOR_FRAC = 1 << TIME_FACTOR_FRAC_BITS;
989
990 const int periods1 = cs->transit_periods[0];
991 const int periods2 = cs->transit_periods[1];
992 const int periods_over_periods1 = std::max(transit_periods - periods1, 0);
993 const int periods_over_periods2 = std::max(periods_over_periods1 - periods2, 0);
994 int periods_over_max = MIN_TIME_FACTOR - MAX_TIME_FACTOR;
995 if (periods2 > -periods_over_max) {
996 periods_over_max += transit_periods - periods1;
997 } else {
998 periods_over_max += 2 * (transit_periods - periods1) - periods2;
999 }
1000
1001 /*
1002 * The time factor is calculated based on the time it took
1003 * (transit_periods) compared two cargo-depending values. The
1004 * range is divided into four parts:
1005 *
1006 * - constant for fast transits
1007 * - linear decreasing with time with a slope of -1 for medium transports
1008 * - linear decreasing with time with a slope of -2 for slow transports
1009 * - after hitting MIN_TIME_FACTOR, the time factor will be asymptotically decreased to a limit of 1 with a scaled 1/(x+1) function.
1010 *
1011 */
1012 if (periods_over_max > 0) {
1013 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.
1014 return BigMulS(dist * time_factor * num_pieces, cs->current_payment, 21 + TIME_FACTOR_FRAC_BITS);
1015 } else {
1016 const int time_factor = std::max(MAX_TIME_FACTOR - periods_over_periods1 - periods_over_periods2, MIN_TIME_FACTOR);
1017 return BigMulS(dist * time_factor * num_pieces, cs->current_payment, 21);
1018 }
1019}
1020
1022static SmallIndustryList _cargo_delivery_destinations;
1023
1034static uint DeliverGoodsToIndustry(const Station *st, CargoType cargo_type, uint num_pieces, IndustryID source, CompanyID company)
1035{
1036 /* Find the nearest industrytile to the station sign inside the catchment area, whose industry accepts the cargo.
1037 * This fails in three cases:
1038 * 1) The station accepts the cargo because there are enough houses around it accepting the cargo.
1039 * 2) The industries in the catchment area temporarily reject the cargo, and the daily station loop has not yet updated station acceptance.
1040 * 3) The results of callbacks CBID_INDUSTRY_REFUSE_CARGO and CBID_INDTILE_CARGO_ACCEPTANCE are inconsistent. (documented behaviour)
1041 */
1042
1043 uint accepted = 0;
1044
1045 for (const auto &i : st->industries_near) {
1046 if (num_pieces == 0) break;
1047
1048 Industry *ind = i.industry;
1049 if (ind->index == source) continue;
1050
1051 auto it = ind->GetCargoAccepted(cargo_type);
1052 /* Check if matching cargo has been found */
1053 if (it == std::end(ind->accepted)) continue;
1054
1055 /* Check if industry temporarily refuses acceptance */
1056 if (IndustryTemporarilyRefusesCargo(ind, cargo_type)) continue;
1057
1058 if (ind->exclusive_supplier != INVALID_OWNER && ind->exclusive_supplier != st->owner) continue;
1059
1060 /* Insert the industry into _cargo_delivery_destinations, if not yet contained */
1062
1063 uint amount = std::min(num_pieces, 0xFFFFu - it->waiting);
1064 it->waiting += amount;
1065 it->GetOrCreateHistory()[THIS_MONTH].accepted += amount;
1066 it->last_accepted = TimerGameEconomy::date;
1067 num_pieces -= amount;
1068 accepted += amount;
1069
1070 /* Update the cargo monitor. */
1071 AddCargoDelivery(cargo_type, company, amount, {source, SourceType::Industry}, st, ind->index);
1072 }
1073
1074 return accepted;
1075}
1076
1089static Money DeliverGoods(int num_pieces, CargoType cargo_type, StationID dest, uint distance, uint16_t periods_in_transit, Company *company, Source src)
1090{
1091 assert(num_pieces > 0);
1092
1093 Station *st = Station::Get(dest);
1094
1095 /* Give the goods to the industry. */
1096 uint accepted_ind = DeliverGoodsToIndustry(st, cargo_type, num_pieces, src.type == SourceType::Industry ? src.ToIndustryID() : IndustryID::Invalid(), company->index);
1097
1098 /* If this cargo type is always accepted, accept all */
1099 uint accepted_total = st->always_accepted.Test(cargo_type) ? num_pieces : accepted_ind;
1100
1101 /* Update station statistics */
1102 if (accepted_total > 0) {
1104 }
1105
1106 /* Update company statistics */
1107 company->cur_economy.delivered_cargo[cargo_type] += accepted_total;
1108
1109 /* Increase town's counter for town effects */
1110 const CargoSpec *cs = CargoSpec::Get(cargo_type);
1111 st->town->received[cs->town_acceptance_effect].new_act += accepted_total;
1112 if (accepted_total - accepted_ind > 0) {
1113 /* Cargo not delivered to an industry must go to the town. */
1114 st->town->GetOrCreateCargoAccepted(cargo_type).history[THIS_MONTH].accepted += accepted_total - accepted_ind;
1115 }
1116
1117 /* Determine profit */
1118 Money profit = GetTransportedGoodsIncome(accepted_total, distance, periods_in_transit, cargo_type);
1119
1120 /* Update the cargo monitor. */
1121 AddCargoDelivery(cargo_type, company->index, accepted_total - accepted_ind, src, st);
1122
1123 /* Modify profit if a subsidy is in effect */
1124 if (CheckSubsidised(cargo_type, company->index, src, st)) {
1125 switch (_settings_game.difficulty.subsidy_multiplier) {
1126 case 0: profit += profit >> 1; break;
1127 case 1: profit *= 2; break;
1128 case 2: profit *= 3; break;
1129 default: profit *= 4; break;
1130 }
1131 }
1132
1133 return profit;
1134}
1135
1142{
1143 const IndustrySpec *indspec = GetIndustrySpec(i->type);
1144 IndustryCallbackMasks cbm = indspec->callback_mask;
1145
1146 i->was_cargo_delivered = true;
1147
1151 } else {
1152 SetWindowDirty(WindowClass::IndustryView, i->index);
1153 }
1154 } else {
1155 for (auto ita = std::begin(i->accepted); ita != std::end(i->accepted); ++ita) {
1156 if (ita->waiting == 0 || !IsValidCargoType(ita->cargo)) continue;
1157
1158 for (auto itp = std::begin(i->produced); itp != std::end(i->produced); ++itp) {
1159 if (!IsValidCargoType(itp->cargo)) continue;
1160 itp->waiting = ClampTo<uint16_t>(itp->waiting + (ita->waiting * indspec->input_cargo_multiplier[ita - std::begin(i->accepted)][itp - std::begin(i->produced)] / 256));
1161 }
1162
1163 ita->waiting = 0;
1164 }
1165 }
1166
1168 TriggerIndustryAnimation(i, IndustryAnimationTrigger::CargoReceived);
1169}
1170
1176CargoPayment::CargoPayment(CargoPaymentID index, Vehicle *front) :
1178 current_station(front->last_station_visited),
1179 front(front)
1180{
1181}
1182
1185{
1186 if (CleaningPool()) return;
1187
1188 this->front->cargo_payment = nullptr;
1189
1190 if (this->visual_profit == 0 && this->visual_transfer == 0) return;
1191
1192 AutoRestoreBackup cur_company(_current_company, this->front->owner);
1193
1194 SubtractMoneyFromCompany(_current_company, CommandCost(this->front->GetExpenseType(true), -this->route_profit));
1195 this->front->profit_this_year += (this->visual_profit + this->visual_transfer) << 8;
1196
1197 const Vehicle *moving_front = this->front->GetMovingFront();
1199 SndPlayVehicleFx(SND_14_CASHTILL, this->front);
1200 }
1201
1202 if (this->visual_transfer != 0) {
1203 ShowFeederIncomeAnimation(moving_front->x_pos, moving_front->y_pos,
1204 moving_front->z_pos, this->visual_transfer, -this->visual_profit);
1205 } else {
1206 ShowCostOrIncomeAnimation(moving_front->x_pos, moving_front->y_pos,
1207 moving_front->z_pos, -this->visual_profit);
1208 }
1209}
1210
1218void CargoPayment::PayFinalDelivery(CargoType cargo, const CargoPacket *cp, uint count, TileIndex current_tile)
1219{
1220 /* Handle end of route payment */
1221 Money profit = DeliverGoods(count, cargo, this->current_station, cp->GetDistance(current_tile), cp->GetPeriodsInTransit(), Company::Get(this->front->owner), cp->GetSource());
1222 this->route_profit += profit;
1223
1224 /* The vehicle's profit is whatever route profit there is minus feeder shares. */
1225 this->visual_profit += profit - cp->GetFeederShare(count);
1226}
1227
1236Money CargoPayment::PayTransfer(CargoType cargo, const CargoPacket *cp, uint count, TileIndex current_tile)
1237{
1238 /* Pay transfer vehicle the difference between the payment for the journey from
1239 * the source to the current point, and the sum of the previous transfer payments */
1240 Money profit = -cp->GetFeederShare(count) + GetTransportedGoodsIncome(
1241 count,
1242 cp->GetDistance(current_tile),
1243 cp->GetPeriodsInTransit(),
1244 cargo);
1245
1246 profit = profit * _settings_game.economy.feeder_payment_share / 100;
1247
1248 this->visual_transfer += profit; // accumulate transfer profits for whole vehicle
1249 return profit; // account for the (virtual) profit already made for the cargo packet
1250}
1251
1257{
1258 Station *curr_station = Station::Get(front_v->last_station_visited);
1259 curr_station->loading_vehicles.push_back(front_v);
1260
1261 /* At this moment loading cannot be finished */
1263
1264 /* Start unloading at the first possible moment */
1265 front_v->load_unload_ticks = 1;
1266
1267 assert(front_v->cargo_payment == nullptr);
1268 /* One CargoPayment per vehicle and the vehicle limit equals the
1269 * limit in number of CargoPayments. Can't go wrong. */
1272 front_v->cargo_payment = CargoPayment::Create(front_v);
1273
1274 std::vector<StationID> next_station;
1275 front_v->GetNextStoppingStation(next_station);
1276 if (front_v->orders == nullptr || front_v->current_order.GetUnloadType() != OrderUnloadType::NoUnload) {
1278 for (Vehicle *v = front_v; v != nullptr; v = v->Next()) {
1279 const GoodsEntry *ge = &st->goods[v->cargo_type];
1280 if (v->cargo_cap > 0 && v->cargo.TotalCount() > 0) {
1281 v->cargo.Stage(
1283 front_v->last_station_visited, next_station,
1284 front_v->current_order.GetUnloadType(), ge,
1285 v->cargo_type, front_v->cargo_payment,
1286 v->GetMovingFront()->GetCargoTile());
1287 if (v->cargo.UnloadCount() > 0) v->vehicle_flags.Set(VehicleFlag::CargoUnloading);
1288 }
1289 }
1290 }
1291}
1292
1299static uint GetLoadAmount(Vehicle *v)
1300{
1301 const Engine *e = v->GetEngine();
1302 uint load_amount = e->info.load_amount;
1303
1304 /* The default loadamount for mail is 1/4 of the load amount for passengers */
1305 bool air_mail = v->type == VehicleType::Aircraft && !Aircraft::From(v)->IsNormalAircraft();
1306 if (air_mail) load_amount = CeilDiv(load_amount, 4);
1307
1308 if (_settings_game.order.gradual_loading) {
1309 uint16_t cb_load_amount = CALLBACK_FAILED;
1310 if (e->GetGRF() != nullptr && e->GetGRF()->grf_version >= 8) {
1311 /* Use callback 36 */
1312 cb_load_amount = GetVehicleProperty(v, PROP_VEHICLE_LOAD_AMOUNT, CALLBACK_FAILED);
1314 /* Use callback 12 */
1315 cb_load_amount = GetVehicleCallback(CBID_VEHICLE_LOAD_AMOUNT, 0, 0, v->engine_type, v);
1316 }
1317 if (cb_load_amount != CALLBACK_FAILED) {
1318 if (e->GetGRF()->grf_version < 8) cb_load_amount = GB(cb_load_amount, 0, 8);
1319 if (cb_load_amount >= 0x100) {
1321 } else if (cb_load_amount != 0) {
1322 load_amount = cb_load_amount;
1323 }
1324 }
1325 }
1326
1327 /* Scale load amount the same as capacity */
1328 if (e->info.misc_flags.Test(EngineMiscFlag::NoDefaultCargoMultiplier) && !air_mail) load_amount = CeilDiv(load_amount * CargoSpec::Get(v->cargo_type)->multiplier, 0x100);
1329
1330 /* Zero load amount breaks a lot of things. */
1331 return std::max(1u, load_amount);
1332}
1333
1343template <class Taction>
1344bool IterateVehicleParts(Vehicle *v, Taction action)
1345{
1346 for (Vehicle *w = v; w != nullptr;
1347 w = w->HasArticulatedPart() ? w->GetNextArticulatedPart() : nullptr) {
1348 if (!action(w)) return false;
1349 if (w->type == VehicleType::Train) {
1350 Train *train = Train::From(w);
1351 if (train->IsMultiheaded() && !action(train->other_multiheaded_part)) return false;
1352 }
1353 }
1354 if (v->type == VehicleType::Aircraft && Aircraft::From(v)->IsNormalAircraft()) return action(v->Next());
1355 return true;
1356}
1357
1362{
1368 bool operator()(const Vehicle *v)
1369 {
1370 return v->cargo.StoredCount() == 0;
1371 }
1372};
1373
1378{
1381
1389
1396 bool operator()(const Vehicle *v)
1397 {
1398 this->consist_capleft[v->cargo_type] -= v->cargo_cap - v->cargo.ReservedCount();
1399 this->refit_mask.Set(EngInfo(v->engine_type)->refit_mask);
1400 return true;
1401 }
1402};
1403
1408{
1410 StationID next_hop;
1411
1417 ReturnCargoAction(Station *st, StationID next_one) : st(st), next_hop(next_one) {}
1418
1425 {
1426 v->cargo.Return(UINT_MAX, &this->st->goods[v->cargo_type].GetOrCreateData().cargo, this->next_hop, v->GetCargoTile());
1427 return true;
1428 }
1429};
1430
1435{
1438 std::span<const StationID> next_station;
1440
1450
1458 {
1459 if (this->do_reserve) {
1460 this->st->goods[v->cargo_type].GetOrCreateData().cargo.Reserve(v->cargo_cap - v->cargo.RemainingCount(),
1461 &v->cargo, this->next_station, v->GetCargoTile());
1462 }
1463 this->consist_capleft[v->cargo_type] += v->cargo_cap - v->cargo.RemainingCount();
1464 return true;
1465 }
1466};
1467
1476static void HandleStationRefit(Vehicle *v, CargoArray &consist_capleft, Station *st, std::span<const StationID> next_station, CargoType new_cargo_type)
1477{
1478 Vehicle *v_start = v->GetFirstEnginePart();
1479 if (!IterateVehicleParts(v_start, IsEmptyAction())) return;
1480
1481 AutoRestoreBackup cur_company(_current_company, v->owner);
1482
1483 CargoTypes refit_mask = v->GetEngine()->info.refit_mask;
1484
1485 /* Remove old capacity from consist capacity and collect refit mask. */
1486 IterateVehicleParts(v_start, PrepareRefitAction(consist_capleft, refit_mask));
1487
1488 bool is_auto_refit = new_cargo_type == CARGO_AUTO_REFIT;
1489 if (is_auto_refit) {
1490 /* Get a refittable cargo type with waiting cargo for next_station or StationID::Invalid(). */
1491 new_cargo_type = v_start->cargo_type;
1492 for (CargoType cargo_type : refit_mask) {
1493 if (st->goods[cargo_type].HasData() && st->goods[cargo_type].GetData().cargo.HasCargoFor(next_station)) {
1494 /* Try to find out if auto-refitting would succeed. In case the refit is allowed,
1495 * the returned refit capacity will be greater than zero. */
1496 auto [cc, refit_capacity, mail_capacity, cargo_capacities] = Command<Commands::RefitVehicle>::Do(DoCommandFlag::QueryCost, v_start->index, cargo_type, 0xFF, true, false, 1); // Auto-refit and only this vehicle including artic parts.
1497 /* Try to balance different loadable cargoes between parts of the consist, so that
1498 * all of them can be loaded. Avoid a situation where all vehicles suddenly switch
1499 * to the first loadable cargo for which there is only one packet. If the capacities
1500 * are equal refit to the cargo of which most is available. This is important for
1501 * consists of only a single vehicle as those will generally have a consist_capleft
1502 * of 0 for all cargoes. */
1503 if (refit_capacity > 0 && (consist_capleft[cargo_type] < consist_capleft[new_cargo_type] ||
1504 (consist_capleft[cargo_type] == consist_capleft[new_cargo_type] &&
1505 st->goods[cargo_type].AvailableCount() > st->goods[new_cargo_type].AvailableCount()))) {
1506 new_cargo_type = cargo_type;
1507 }
1508 }
1509 }
1510 }
1511
1512 /* Refit if given a valid cargo. */
1513 if (new_cargo_type < NUM_CARGO && new_cargo_type != v_start->cargo_type) {
1514 /* StationID::Invalid() because in the DistributionType::Manual case that's correct and in the DT_(A)SYMMETRIC
1515 * cases the next hop of the vehicle doesn't really tell us anything if the cargo had been
1516 * "via any station" before reserving. We rather produce some more "any station" cargo than
1517 * misrouting it. */
1518 IterateVehicleParts(v_start, ReturnCargoAction(st, StationID::Invalid()));
1519 CommandCost cost = ExtractCommandCost(Command<Commands::RefitVehicle>::Do(DoCommandFlag::Execute, v_start->index, new_cargo_type, 0xFF, true, false, 1)); // Auto-refit and only this vehicle including artic parts.
1520 if (cost.Succeeded()) v->First()->profit_this_year -= cost.GetCost() << 8;
1521 }
1522
1523 /* Add new capacity to consist capacity and reserve cargo */
1524 IterateVehicleParts(v_start, FinalizeRefitAction(consist_capleft, st, next_station,
1525 is_auto_refit || v->First()->current_order.IsFullLoadOrder()));
1526}
1527
1534static bool MayLoadUnderExclusiveRights(const Station *st, const Vehicle *v)
1535{
1536 return st->owner != OWNER_NONE || st->town->exclusive_counter == 0 || st->town->exclusivity == v->owner;
1537}
1538
1539struct ReserveCargoAction {
1540 Station *st;
1541 std::span<const StationID> next_station;
1542
1543 ReserveCargoAction(Station *st, std::span<const StationID> next_station) :
1544 st(st), next_station(next_station) {}
1545
1546 bool operator()(Vehicle *v)
1547 {
1549 st->goods[v->cargo_type].GetOrCreateData().cargo.Reserve(v->cargo_cap - v->cargo.RemainingCount(),
1550 &v->cargo, next_station, v->GetCargoTile());
1551 }
1552
1553 return true;
1554 }
1555
1556};
1557
1566static void ReserveConsist(Station *st, Vehicle *u, CargoArray *consist_capleft, std::span<const StationID> next_station)
1567{
1568 /* If there is a cargo payment not all vehicles of the consist have tried to do the refit.
1569 * In that case, only reserve if it's a fixed refit and the equivalent of "articulated chain"
1570 * a vehicle belongs to already has the right cargo. */
1571 bool must_reserve = !u->current_order.IsRefit() || u->cargo_payment == nullptr;
1572 for (Vehicle *v = u; v != nullptr; v = v->Next()) {
1573 assert(v->cargo_cap >= v->cargo.RemainingCount());
1574
1575 /* Exclude various ways in which the vehicle might not be the head of an equivalent of
1576 * "articulated chain". Also don't do the reservation if the vehicle is going to refit
1577 * to a different cargo and hasn't tried to do so, yet. */
1578 if (!v->IsArticulatedPart() &&
1579 (v->type != VehicleType::Train || !Train::From(v)->IsRearDualheaded()) &&
1580 (v->type != VehicleType::Aircraft || Aircraft::From(v)->IsNormalAircraft()) &&
1581 (must_reserve || u->current_order.GetRefitCargo() == v->cargo_type)) {
1582 IterateVehicleParts(v, ReserveCargoAction(st, next_station));
1583 }
1584 if (consist_capleft == nullptr || v->cargo_cap == 0) continue;
1585 (*consist_capleft)[v->cargo_type] += v->cargo_cap - v->cargo.RemainingCount();
1586 }
1587}
1588
1596static void UpdateLoadUnloadTicks(Vehicle *front, const Station *st, int ticks)
1597{
1598 if (front->type == VehicleType::Train && _settings_game.order.station_length_loading_penalty) {
1599 /* Each platform tile is worth 2 rail vehicles. */
1600 int overhang = front->GetGroundVehicleCache()->cached_total_length - st->GetPlatformLength(front->GetMovingFront()->tile) * TILE_SIZE;
1601 if (overhang > 0) {
1602 ticks <<= 1;
1603 ticks += (overhang * ticks) / 8;
1604 }
1605 }
1606 /* Always wait at least 1, otherwise we'll wait 'infinitively' long. */
1607 front->load_unload_ticks = std::max(1, ticks);
1608}
1609
1614static void LoadUnloadVehicle(Vehicle *front)
1615{
1616 assert(front->current_order.IsType(OT_LOADING));
1617
1618 StationID last_visited = front->last_station_visited;
1619 Station *st = Station::Get(last_visited);
1620
1621 std::vector<StationID> next_station;
1622 front->GetNextStoppingStation(next_station);
1623 bool use_autorefit = front->current_order.IsRefit() && front->current_order.GetRefitCargo() == CARGO_AUTO_REFIT;
1624 CargoArray consist_capleft{};
1625 if (_settings_game.order.improved_load && use_autorefit ?
1626 front->cargo_payment == nullptr : (front->current_order.IsFullLoadOrder())) {
1627 ReserveConsist(st, front,
1628 (use_autorefit && front->load_unload_ticks != 0) ? &consist_capleft : nullptr,
1629 next_station);
1630 }
1631
1632 /* We have not waited enough time till the next round of loading/unloading */
1633 if (front->load_unload_ticks != 0) return;
1634
1635 const Vehicle *moving_front = front->GetMovingFront();
1636 if (front->type == VehicleType::Train && (!IsTileType(moving_front->tile, TileType::Station) || GetStationIndex(moving_front->tile) != st->index)) {
1637 /* The train reversed in the station. Take the "easy" way
1638 * out and let the train just leave as it always did. */
1640 front->load_unload_ticks = 1;
1641 return;
1642 }
1643
1644 int new_load_unload_ticks = 0;
1645 bool dirty_vehicle = false;
1646 bool dirty_station = false;
1647
1648 bool completely_emptied = true;
1649 bool anything_unloaded = false;
1650 bool anything_loaded = false;
1651 CargoTypes full_load_amount{};
1652 CargoTypes cargo_not_full{};
1653 CargoTypes cargo_full{};
1654 CargoTypes reservation_left{};
1655
1656 front->cur_speed = 0;
1657
1658 CargoPayment *payment = front->cargo_payment;
1659
1660 uint artic_part = 0; // Articulated part we are currently trying to load. (not counting parts without capacity)
1661 for (Vehicle *v = front; v != nullptr; v = v->Next()) {
1662 if (v == front || !v->Previous()->HasArticulatedPart()) artic_part = 0;
1663 if (v->cargo_cap == 0) continue;
1664 artic_part++;
1665
1666 GoodsEntry *ge = &st->goods[v->cargo_type];
1667
1668 if (v->vehicle_flags.Test(VehicleFlag::CargoUnloading) && front->current_order.GetUnloadType() != OrderUnloadType::NoUnload) {
1669 uint cargo_count = v->cargo.UnloadCount();
1670 uint amount_unloaded = _settings_game.order.gradual_loading ? std::min(cargo_count, GetLoadAmount(v)) : cargo_count;
1671 bool remaining = false; // Are there cargo entities in this vehicle that can still be unloaded here?
1672
1673 if (!ge->status.Test(GoodsEntry::State::Acceptance) && v->cargo.ActionCount(VehicleCargoList::MoveToAction::Deliver) > 0) {
1674 /* The station does not accept our goods anymore. */
1676 /* Transfer instead of delivering. */
1677 v->cargo.Reassign<VehicleCargoList::MoveToAction::Deliver, VehicleCargoList::MoveToAction::Transfer>(
1678 v->cargo.ActionCount(VehicleCargoList::MoveToAction::Deliver));
1679 } else {
1680 uint new_remaining = v->cargo.RemainingCount() + v->cargo.ActionCount(VehicleCargoList::MoveToAction::Deliver);
1681 if (v->cargo_cap < new_remaining) {
1682 /* Return some of the reserved cargo to not overload the vehicle. */
1683 v->cargo.Return(new_remaining - v->cargo_cap, &ge->GetOrCreateData().cargo, StationID::Invalid(), v->GetCargoTile());
1684 }
1685
1686 /* Keep instead of delivering. This may lead to no cargo being unloaded, so ...*/
1687 v->cargo.Reassign<VehicleCargoList::MoveToAction::Deliver, VehicleCargoList::MoveToAction::Keep>(
1688 v->cargo.ActionCount(VehicleCargoList::MoveToAction::Deliver));
1689
1690 /* ... say we unloaded something, otherwise we'll think we didn't unload
1691 * something and we didn't load something, so we must be finished
1692 * at this station. Setting the unloaded means that we will get a
1693 * retry for loading in the next cycle. */
1694 anything_unloaded = true;
1695 }
1696 }
1697
1698 if (v->cargo.ActionCount(VehicleCargoList::MoveToAction::Transfer) > 0) {
1699 /* Mark the station dirty if we transfer, but not if we only deliver. */
1700 dirty_station = true;
1701
1702 if (!ge->HasRating()) {
1703 /* Upon transferring cargo, make sure the station has a rating. Fake a pickup for the
1704 * first unload to prevent the cargo from quickly decaying after the initial drop. */
1705 ge->time_since_pickup = 0;
1707 }
1708 }
1709
1710 assert(payment != nullptr);
1711 amount_unloaded = v->cargo.Unload(amount_unloaded, &ge->GetOrCreateData().cargo, v->cargo_type, payment, v->GetCargoTile());
1712 remaining = v->cargo.UnloadCount() > 0;
1713 if (amount_unloaded > 0) {
1714 dirty_vehicle = true;
1715 anything_unloaded = true;
1716 new_load_unload_ticks += amount_unloaded;
1717
1718 /* Deliver goods to the station */
1719 st->time_since_unload = 0;
1720 }
1721
1722 if (_settings_game.order.gradual_loading && remaining) {
1723 completely_emptied = false;
1724 } else {
1725 /* We have finished unloading (cargo count == 0) */
1726 v->vehicle_flags.Reset(VehicleFlag::CargoUnloading);
1727 }
1728
1729 continue;
1730 }
1731
1732 /* Do not pick up goods when we have no-load set or loading is stopped. */
1734
1735 /* This order has a refit, if this is the first vehicle part carrying cargo and the whole vehicle is empty, try refitting. */
1736 if (front->current_order.IsRefit() && artic_part == 1) {
1737 HandleStationRefit(v, consist_capleft, st, next_station, front->current_order.GetRefitCargo());
1738 ge = &st->goods[v->cargo_type];
1739 }
1740
1741 /* As we're loading here the following link can carry the full capacity of the vehicle. */
1742 v->refit_cap = v->cargo_cap;
1743
1744 /* update stats */
1745 int t;
1746 switch (front->type) {
1747 case VehicleType::Train:
1748 case VehicleType::Ship:
1749 t = front->vcache.cached_max_speed;
1750 break;
1751
1752 case VehicleType::Road:
1753 t = front->vcache.cached_max_speed / 2;
1754 break;
1755
1757 t = Aircraft::From(front)->GetSpeedOldUnits(); // Convert to old units.
1758 break;
1759
1760 default: NOT_REACHED();
1761 }
1762
1763 /* if last speed is 0, we treat that as if no vehicle has ever visited the station. */
1766
1767 assert(v->cargo_cap >= v->cargo.StoredCount());
1768 /* Capacity available for loading more cargo. */
1769 uint cap_left = v->cargo_cap - v->cargo.StoredCount();
1770
1771 if (cap_left > 0) {
1772 /* If vehicle can load cargo, reset time_since_pickup. */
1773 ge->time_since_pickup = 0;
1774
1775 /* If there's goods waiting at the station, and the vehicle
1776 * has capacity for it, load it on the vehicle. */
1777 if ((v->cargo.ActionCount(VehicleCargoList::MoveToAction::Load) > 0 || ge->AvailableCount() > 0) && MayLoadUnderExclusiveRights(st, v)) {
1778 if (v->cargo.StoredCount() == 0) TriggerVehicleRandomisation(v, VehicleRandomTrigger::NewCargo);
1779 if (_settings_game.order.gradual_loading) cap_left = std::min(cap_left, GetLoadAmount(v));
1780
1781 uint loaded = ge->GetOrCreateData().cargo.Load(cap_left, &v->cargo, next_station, v->GetCargoTile());
1782 if (v->cargo.ActionCount(VehicleCargoList::MoveToAction::Load) > 0) {
1783 /* Remember if there are reservations left so that we don't stop
1784 * loading before they're loaded. */
1785 reservation_left.Set(v->cargo_type);
1786 }
1787
1788 /* Store whether the maximum possible load amount was loaded or not.*/
1789 if (loaded == cap_left) {
1790 full_load_amount.Set(v->cargo_type);
1791 } else {
1792 full_load_amount.Reset(v->cargo_type);
1793 }
1794
1795 /* TODO: Regarding this, when we do gradual loading, we
1796 * should first unload all vehicles and then start
1797 * loading them. Since this will cause
1798 * VEHICLE_TRIGGER_EMPTY to be called at the time when
1799 * the whole vehicle chain is really totally empty, the
1800 * completely_emptied assignment can then be safely
1801 * removed; that's how TTDPatch behaves too. --pasky */
1802 if (loaded > 0) {
1803 completely_emptied = false;
1804 anything_loaded = true;
1805
1806 st->time_since_load = 0;
1807 st->last_vehicle_type = v->type;
1808
1809 if (ge->GetData().cargo.TotalCount() == 0) {
1811 TriggerStationAnimation(st, st->xy, StationAnimationTrigger::CargoTaken, v->cargo_type);
1812 TriggerAirportAnimation(st, AirportAnimationTrigger::CargoTaken, v->cargo_type);
1814 TriggerRoadStopAnimation(st, st->xy, StationAnimationTrigger::CargoTaken, v->cargo_type);
1815 }
1816
1817 new_load_unload_ticks += loaded;
1818
1819 dirty_vehicle = dirty_station = true;
1820 }
1821 }
1822 }
1823
1824 if (v->cargo.StoredCount() >= v->cargo_cap) {
1825 cargo_full.Set(v->cargo_type);
1826 } else {
1827 cargo_not_full.Set(v->cargo_type);
1828 }
1829 }
1830
1831 if (anything_loaded || anything_unloaded) {
1832 if (front->type == VehicleType::Train) {
1834 TriggerStationAnimation(st, moving_front->tile, StationAnimationTrigger::VehicleLoads);
1835 } else if (front->type == VehicleType::Road) {
1837 TriggerRoadStopAnimation(st, front->tile, StationAnimationTrigger::VehicleLoads);
1838 }
1839 }
1840
1841 /* Only set completely_emptied, if we just unloaded all remaining cargo */
1842 completely_emptied &= anything_unloaded;
1843
1844 if (!anything_unloaded) delete payment;
1845
1847 if (anything_loaded || anything_unloaded) {
1848 if (_settings_game.order.gradual_loading) {
1849 /* The time it takes to load one 'slice' of cargo or passengers depends
1850 * on the vehicle type - the values here are those found in TTDPatch */
1851 constexpr VehicleTypeIndexArray<const uint> gradual_loading_wait_time = { 40, 20, 10, 20 };
1852
1853 new_load_unload_ticks = gradual_loading_wait_time[front->type];
1854 }
1855 /* We loaded less cargo than possible for all cargo types and it's not full
1856 * load and we're not supposed to wait any longer: stop loading. */
1857 if (!anything_unloaded && full_load_amount.None() && reservation_left.None() && !front->current_order.IsFullLoadOrder() &&
1858 front->current_order_time >= std::max(front->current_order.GetTimetabledWait() - front->lateness_counter, 0)) {
1860 }
1861
1862 UpdateLoadUnloadTicks(front, st, new_load_unload_ticks);
1863 } else {
1864 UpdateLoadUnloadTicks(front, st, 20); // We need the ticks for link refreshing.
1865 bool finished_loading = true;
1866 if (front->current_order.IsFullLoadOrder()) {
1868 /* if the aircraft carries passengers and is NOT full, then
1869 * continue loading, no matter how much mail is in */
1870 if ((front->type == VehicleType::Aircraft && IsCargoInClass(front->cargo_type, CargoClass::Passengers) && front->cargo_cap > front->cargo.StoredCount()) ||
1871 (cargo_not_full.Any() && cargo_full.Reset(cargo_not_full).None())) { // There are still non-full cargoes
1872 finished_loading = false;
1873 }
1874 } else if (cargo_not_full.Any()) {
1875 finished_loading = false;
1876 }
1877
1878 /* Refresh next hop stats if we're full loading to make the links
1879 * known to the distribution algorithm and allow cargo to be sent
1880 * along them. Otherwise the vehicle could wait for cargo
1881 * indefinitely if it hasn't visited the other links yet, or if the
1882 * links die while it's loading. */
1883 if (!finished_loading) LinkRefresher::Run(front, true, true);
1884 }
1885
1886 front->vehicle_flags.Set(VehicleFlag::LoadingFinished, finished_loading);
1887 }
1888
1889 /* Calculate the loading indicator fill percent and display
1890 * In the Game Menu do not display indicators
1891 * If _settings_client.gui.loading_indicators == 2, show indicators (bool can be promoted to int as 0 or 1 - results in 2 > 0,1 )
1892 * if _settings_client.gui.loading_indicators == 1, _local_company must be the owner or must be a spectator to show ind., so 1 > 0
1893 * if _settings_client.gui.loading_indicators == 0, do not display indicators ... 0 is never greater than anything
1894 */
1895 if (_game_mode != GameMode::Menu && (_settings_client.gui.loading_indicators > (uint)(front->owner != _local_company && _local_company != COMPANY_SPECTATOR))) {
1896 StringID percent_up_down = STR_NULL;
1897 int percent = CalcPercentVehicleFilled(front, &percent_up_down);
1898 if (front->fill_percent_te_id == INVALID_TE_ID) {
1899 front->fill_percent_te_id = ShowFillingPercent(moving_front->x_pos, moving_front->y_pos, moving_front->z_pos + 20, percent, percent_up_down);
1900 } else {
1901 UpdateFillingPercent(front->fill_percent_te_id, percent, percent_up_down);
1902 }
1903 }
1904
1905 if (completely_emptied) {
1906 /* Make sure the vehicle is marked dirty, since we need to update the NewGRF
1907 * properties such as weight, power and TE whenever the trigger runs. */
1908 dirty_vehicle = true;
1909 TriggerVehicleRandomisation(front, VehicleRandomTrigger::Empty);
1910 }
1911
1912 if (dirty_vehicle) {
1914 SetWindowDirty(WindowClass::VehicleDetails, front->index);
1915 front->MarkDirty();
1916 }
1917 if (dirty_station) {
1918 st->MarkTilesDirty(true);
1919 SetWindowDirty(WindowClass::StationView, st->index);
1920 SetWindowDirty(WindowClass::StationList, st->owner);
1921 }
1922}
1923
1930{
1931 /* No vehicle is here... */
1932 if (st->loading_vehicles.empty()) return;
1933
1934 Vehicle *last_loading = nullptr;
1935
1936 /* Check if anything will be loaded at all. Otherwise we don't need to reserve either. */
1937 for (Vehicle *v : st->loading_vehicles) {
1938 if (v->vehstatus.Any({VehState::Stopped, VehState::Crashed})) continue;
1939
1940 assert(v->load_unload_ticks != 0);
1941 if (--v->load_unload_ticks == 0) last_loading = v;
1942 }
1943
1944 /* We only need to reserve and load/unload up to the last loading vehicle.
1945 * Anything else will be forgotten anyway after returning from this function.
1946 *
1947 * Especially this means we do _not_ need to reserve cargo for a single
1948 * consist in a station which is not allowed to load yet because its
1949 * load_unload_ticks is still not 0.
1950 */
1951 if (last_loading == nullptr) return;
1952
1953 for (Vehicle *v : st->loading_vehicles) {
1954 if (!v->vehstatus.Any({VehState::Stopped, VehState::Crashed})) LoadUnloadVehicle(v);
1955 if (v == last_loading) break;
1956 }
1957
1958 /* Call the production machinery of industries */
1961 }
1963}
1964
1968static const IntervalTimer<TimerGameCalendar> _calendar_inflation_monthly({TimerGameCalendar::Trigger::Month, TimerGameCalendar::Priority::Company}, [](auto)
1969{
1970 if (_settings_game.economy.inflation) {
1971 AddInflation();
1973 }
1974});
1975
1979static const IntervalTimer<TimerGameEconomy> _economy_companies_monthly({ TimerGameEconomy::Trigger::Month, TimerGameEconomy::Priority::Company }, [](auto)
1980{
1983 HandleEconomyFluctuations();
1984});
1985
1986static void DoAcquireCompany(Company *c, bool hostile_takeover)
1987{
1988 CompanyID ci = c->index;
1989
1990 auto cni = std::make_unique<CompanyNewsInformation>(STR_NEWS_COMPANY_MERGER_TITLE, c, Company::Get(_current_company));
1991 EncodedString headline = hostile_takeover
1992 ? GetEncodedString(STR_NEWS_MERGER_TAKEOVER_TITLE, cni->company_name, cni->other_company_name)
1993 : GetEncodedString(STR_NEWS_COMPANY_MERGER_DESCRIPTION, cni->company_name, cni->other_company_name, c->bankrupt_value);
1994 AddCompanyNewsItem(std::move(headline), std::move(cni));
1995 AI::BroadcastNewEvent(new ScriptEventCompanyMerger(ci, _current_company));
1996 Game::NewEvent(new ScriptEventCompanyMerger(ci, _current_company));
1997
1999
2000 if (c->is_ai) AI::Stop(c->index);
2001
2003 InvalidateWindowClassesData(WindowClass::TrainList, 0);
2004 InvalidateWindowClassesData(WindowClass::ShipList, 0);
2005 InvalidateWindowClassesData(WindowClass::RoadVehicleList, 0);
2006 InvalidateWindowClassesData(WindowClass::AircraftList, 0);
2007 InvalidateWindowData(WindowClass::NetworkClientList, 0);
2008
2009 delete c;
2010}
2011
2022CommandCost CmdBuyCompany(DoCommandFlags flags, CompanyID target_company, bool hostile_takeover)
2023{
2024 Company *c = Company::GetIfValid(target_company);
2025 if (c == nullptr) return CMD_ERROR;
2026
2027 /* If you do a hostile takeover but the company went bankrupt, buy it via bankruptcy rules. */
2028 if (hostile_takeover && c->bankrupt_asked.Test(_current_company)) hostile_takeover = false;
2029
2030 /* Disable takeovers when not asked */
2031 if (!hostile_takeover && !c->bankrupt_asked.Test(_current_company)) return CMD_ERROR;
2032
2033 /* Only allow hostile takeover of AI companies and when in single player */
2034 if (hostile_takeover && !c->is_ai) return CMD_ERROR;
2035 if (hostile_takeover && _networking) return CMD_ERROR;
2036
2037 /* Disable taking over the local company in singleplayer mode */
2038 if (!_networking && _local_company == c->index) return CMD_ERROR;
2039
2040 /* Do not allow companies to take over themselves */
2041 if (target_company == _current_company) return CMD_ERROR;
2042
2043 /* Do not allow takeover if the resulting company would have too many vehicles. */
2044 if (!CheckTakeoverVehicleLimit(_current_company, target_company)) return CommandCost(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME);
2045
2046 /* Get the cost here as the company is deleted in DoAcquireCompany.
2047 * For bankruptcy this amount is calculated when the offer was made;
2048 * for hostile takeover you pay the current price. */
2049 CommandCost cost(ExpensesType::Other, hostile_takeover ? CalculateHostileTakeoverValue(c) : c->bankrupt_value);
2050
2051 if (flags.Test(DoCommandFlag::Execute)) {
2052 DoAcquireCompany(c, hostile_takeover);
2053 }
2054 return cost;
2055}
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.
@ StopLoading
Don't load anymore during the next load cycle.
@ LoadingFinished
Vehicle has finished loading.
@ CargoUnloading
Vehicle is unloading cargo.
static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Types related to cargoes...
bool IsValidCargoType(CargoType cargo)
Test whether cargo type is not INVALID_CARGO.
Definition cargo_type.h:112
static constexpr CargoType CARGO_AUTO_REFIT
Automatically choose cargo type when doing auto refitting.
Definition cargo_type.h:80
EnumBitSet< CargoType, uint64_t > CargoTypes
Bitset of CargoType elements.
Definition cargo_type.h:115
CargoType
Cargo slots to indicate a cargo type within a game.
Definition cargo_type.h:22
void ClearCargoDeliveryMonitoring(CompanyID company)
Clear all delivery cargo monitors.
void ClearCargoPickupMonitoring(CompanyID company)
Clear all pick-up cargo monitors.
void AddCargoDelivery(CargoType cargo_type, CompanyID company, uint32_t amount, Source src, const Station *st, IndustryID dest)
Cargo was delivered to its final destination, update the pickup and delivery maps.
Cargo transport monitoring declarations.
@ Passengers
Passengers.
Definition cargotype.h:50
bool IsCargoInClass(CargoType cargo, CargoClasses cc)
Does a given cargo have any cargo class from cc.
Definition cargotype.h:288
static void BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company=CompanyID::Invalid())
Broadcast a new event to all active AIs.
Definition ai_core.cpp:250
static void Stop(CompanyID company)
Stop a company to be controlled by an AI.
Definition ai_core.cpp:113
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr bool None() const
Test if none of the values are set.
constexpr Timpl & Reset()
Reset all bits.
constexpr Timpl & Set()
Set all bits.
constexpr bool Any(const Timpl &other) const
Test if any of the given values are set.
Common return value for all commands.
bool Succeeded() const
Did this command succeed?
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
Money GetCost() const
The costs as made up to this moment.
Container for an encoded string, created by GetEncodedString.
const GRFFile * GetGRF() const
Retrieve the NewGRF the engine is tied to.
GrfID GetGRFID() const
Retrieve the GRF ID of the NewGRF the engine is tied to.
Definition engine.cpp:185
Iterate a range of enum values.
UnitID UseID(UnitID index)
Use a unit number.
Definition vehicle.cpp:1890
UnitID NextID() const
Find first unused unit number.
Definition vehicle.cpp:1875
static void NewEvent(class ScriptEvent *event)
Queue a new event for the game script.
An interval timer will fire every interval, and will continue to fire until it is deleted.
Definition timer.h:76
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
uint TotalCount() const
Returns total count of cargo at the station, including cargo which is already reserved for loading.
uint Load(uint max_move, VehicleCargoList *dest, std::span< const StationID > next, TileIndex current_tile)
Loads cargo onto a vehicle.
static Year year
Current year, starting at 0.
static constexpr TimerGame< struct Calendar >::Year ORIGINAL_MAX_YEAR
static constexpr TimerGame< struct Calendar >::Year ORIGINAL_BASE_YEAR
static Date date
Current date in days (day counter).
static Month month
Current month (0..11).
A sort-of mixin that implements 'at(pos)' and 'operator[](pos)' only for a specific type.
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.
uint RemainingCount() const
Returns the sum of cargo to be kept in the vehicle at the current station.
uint StoredCount() const
Returns sum of cargo on board the vehicle (ie not only reserved).
Functions related to commands.
CommandCost & ExtractCommandCost(Tret &ret)
Extract the CommandCost from a command proc result.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
@ QueryCost
query cost only, don't build.
@ Execute
execute the given command
@ Bankrupt
company bankrupts, skip money check, skip vehicle on tile check in some cases
EnumBitSet< DoCommandFlag, uint16_t > DoCommandFlags
Bitset of DoCommandFlag elements.
int CompanyServiceInterval(const Company *c, VehicleType type)
Get the service interval for the given company and vehicle type.
static void SubtractMoneyFromCompany(Company *c, const CommandCost &cost)
Deduct costs of a command from the money of a company.
void SetLocalCompany(CompanyID new_company, bool switching_game)
Sets the local company and updates the settings that are set on a per-company basis to reflect the co...
void CompanyAdminUpdate(const Company *company)
Called whenever company related information changes in order to notify admins.
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.
bool CheckTakeoverVehicleLimit(CompanyID cbig, CompanyID csmall)
Can company cbig buy company csmall without exceeding vehicle limits?
CompanyID _current_company
Company currently doing an action.
Command definitions related to companies.
Functions related to companies.
bool IsLocalCompany()
Is the current company the local company?
GUI Functions related to companies.
void CloseCompanyWindows(CompanyID company)
Close all windows of a company.
Definition window.cpp:1271
@ Delete
Delete a company.
static constexpr CompanyID COMPANY_SPECTATOR
The client is spectating.
static const uint MAX_HISTORY_QUARTERS
The maximum number of quarters kept as performance's history.
static constexpr Owner OWNER_NONE
The tile has no ownership.
static constexpr Owner INVALID_OWNER
An invalid owner.
@ Bankrupt
The company went belly-up.
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:1534
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:1596
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:205
static void ReserveConsist(Station *st, Vehicle *u, CargoArray *consist_capleft, std::span< const StationID > next_station)
Reserves cargo if the full load order and improved_load is set or if the current order allows autoref...
Definition economy.cpp:1566
void ChangeOwnershipOfCompanyItems(Owner old_owner, Owner new_owner)
Change the ownership of all the items of a company.
Definition economy.cpp:325
static void CompaniesPayInterest()
Let all companies pay the monthly interest on their loan.
Definition economy.cpp:805
static const IntervalTimer< TimerGameEconomy > _economy_companies_monthly({ TimerGameEconomy::Trigger::Month, TimerGameEconomy::Priority::Company }, [](auto) { CompaniesGenStatistics();CompaniesPayInterest();HandleEconomyFluctuations();})
Every economy month update of company economic data, plus economy fluctuations.
static const IntervalTimer< TimerGameCalendar > _calendar_inflation_monthly({TimerGameCalendar::Trigger::Month, TimerGameCalendar::Priority::Company}, [](auto) { if(_settings_game.economy.inflation) { AddInflation();RecomputePrices();} })
Every calendar month update of inflation.
void LoadUnloadStation(Station *st)
Load/unload the vehicles in this station according to the order they entered.
Definition economy.cpp:1929
void RecomputePrices()
Computes all prices, payments and maximum loan.
Definition economy.cpp:738
static uint DeliverGoodsToIndustry(const Station *st, CargoType cargo_type, uint num_pieces, IndustryID source, CompanyID company)
Transfer goods from station to industry.
Definition economy.cpp:1034
static void LoadUnloadVehicle(Vehicle *front)
Loads/unload the vehicle if possible.
Definition economy.cpp:1614
Money CalculateHostileTakeoverValue(const Company *c)
Calculate what you have to pay to take over a company.
Definition economy.cpp:180
static Money CalculateCompanyAssetValue(const Company *c)
Calculate the value of the assets of a company.
Definition economy.cpp:118
static SmallIndustryList _cargo_delivery_destinations
The industries we've currently brought cargo to.
Definition economy.cpp:1022
void PrepareUnload(Vehicle *front_v)
Prepare the vehicle to be unloaded.
Definition economy.cpp:1256
static uint GetLoadAmount(Vehicle *v)
Gets the amount of cargo the given vehicle can load in the current tick.
Definition economy.cpp:1299
static void HandleStationRefit(Vehicle *v, CargoArray &consist_capleft, Station *st, std::span< const StationID > next_station, CargoType new_cargo_type)
Refit a vehicle in a station.
Definition economy.cpp:1476
void SetPriceBaseMultiplier(Price price, int factor)
Change a price base by the given factor.
Definition economy.cpp:874
Money GetPrice(Price index, uint cost_factor, const GRFFile *grf_file, int shift)
Determine a certain price.
Definition economy.cpp:941
static void TriggerIndustryProduction(Industry *i)
Inform the industry about just delivered cargo DeliverGoodsToIndustry() silently incremented incoming...
Definition economy.cpp:1141
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:1344
static Money DeliverGoods(int num_pieces, CargoType cargo_type, StationID dest, uint distance, uint16_t periods_in_transit, Company *company, Source src)
Delivers goods to industries/towns and calculates the payment.
Definition economy.cpp:1089
Prices _price
Prices and also the fractional part.
Definition economy.cpp:109
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:84
void InitializeEconomy()
Resets economy to initial values.
Definition economy.cpp:926
static void CompanyCheckBankrupt(Company *c)
Check for bankruptcy of a company.
Definition economy.cpp:551
void ResetPriceBaseMultipliers()
Reset changes to the price base multipliers.
Definition economy.cpp:862
static void CompaniesGenStatistics()
Update the finances of all companies.
Definition economy.cpp:642
bool AddInflation(bool check_year)
Add monthly inflation.
Definition economy.cpp:700
CommandCost CmdBuyCompany(DoCommandFlags flags, CompanyID target_company, bool hostile_takeover)
Buy up another company.
Definition economy.cpp:2022
const EnumIndexArray< ScoreInfo, ScoreID, ScoreID::End > _score_info
Score info, values used for computing the detailed performance rating.
Definition economy.cpp:94
Money CalculateCompanyValue(const Company *c, bool including_loan)
Calculate the value of the company.
Definition economy.cpp:153
void StartupIndustryDailyChanges(bool init_counter)
Initialize the variables that will maintain the daily industry change system.
Definition economy.cpp:884
Base classes related to the economy.
Pool< CargoPayment, CargoPaymentID, 512 > CargoPaymentPool
Type of pool to store cargo payments in; little over 1 million.
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?
ScoreID
Score categories in the detailed performance rating.
@ Delivered
Units of cargo delivered in the last four quarter.
@ MinIncome
Income in the quarter with the lowest profit of the last 12 quarters.
@ Vehicles
Number of vehicles that turned profit last year.
@ End
Score ID end marker.
@ Stations
Number of recently-serviced stations.
@ Total
Total points out of possible points ,must always be the last entry.
@ Loan
The amount of money company can take as a loan.
@ MaxIncome
Income in the quarter with the highest profit of the last 12 quarters.
@ MinProfit
The profit of the vehicle with the lowest income.
@ Money
Amount of money company has in the bank.
@ Cargo
Number of types of cargo delivered in the last four quarter.
static const int MIN_PRICE_MODIFIER
Maximum NewGRF price modifiers.
EnumIndexArray< Money, Price, Price::End > Prices
Prices of everything.
@ LoanInterest
Interest payments over the loan.
@ Property
Property costs.
@ Other
Other expenses.
@ Construction
Price is affected by "construction cost" difficulty setting.
@ Running
Price is affected by "vehicle running cost" difficulty setting.
static const int LOAN_INTERVAL
The "steps" in loan size, in British Pounds!
static const uint64_t MAX_INFLATION
Maximum inflation (including fractional part) without causing overflows in int64_t price computations...
Price
Enumeration of all base prices for use with Prices.
@ End
Price base end marker.
@ StationValue
Stations value and additional constant company running fee.
static constexpr int SCORE_MAX
The max score that can be in the performance history.
Base class for engines.
@ NoDefaultCargoMultiplier
Use the new capacity algorithm. The default cargotype of the vehicle does not affect capacity multipl...
EnumClassIndexContainer< std::array< T, to_underlying(N)>, Index > EnumIndexArray
A typedef for EnumClassIndexContainer using std::array as the backing container type.
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:250
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition gfx.cpp:1548
virtual void MarkDirty()
Marks the vehicles to be redrawn and updates cached variables.
Base of all industries.
const IndustrySpec * GetIndustrySpec(IndustryType thistype)
Accessor for array _industry_specs.
@ CargoReceived
Cargo has been delivered.
@ CargoReceived
Trigger when cargo is received .
void ChangeTileOwner(TileIndex tile, Owner old_owner, Owner new_owner)
Change the owner of a tile.
constexpr T ScaleByPercentage(U num, uint16_t percentage)
Scale a number by the required percentage.
constexpr uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
constexpr T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition math_func.hpp:79
constexpr To ClampTo(From value)
Clamp the given value down to lie within the requested type.
void ShowCostOrIncomeAnimation(int x, int y, int z, Money cost)
Display animated income or costs on the map.
Definition misc_gui.cpp:508
void ShowFeederIncomeAnimation(int x, int y, int z, Money transfer, Money income)
Display animated feeder income.
Definition misc_gui.cpp:531
void UpdateFillingPercent(TextEffectID te_id, uint8_t percent, StringID string)
Update vehicle loading indicators.
Definition misc_gui.cpp:571
TextEffectID ShowFillingPercent(int x, int y, int z, uint8_t percent, StringID string)
Display vehicle loading indicators.
Definition misc_gui.cpp:556
bool _networking
are we in networking mode?
Definition network.cpp:63
bool _network_server
network-server is active
Definition network.cpp:64
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 is not part of anything.
NewGRF handling of airport tiles.
@ ProfitCalc
custom profit calculation
@ Production256Ticks
call production callback every 256 ticks
@ ProductionCargoArrival
call production callback when cargo arrives at the industry
@ 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.
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
EnumBitSet< IndustryCallbackMask, uint16_t > IndustryCallbackMasks
Bitset of IndustryCallbackMask elements.
Cargo support for NewGRFs.
void ErrorUnknownCallbackResult(GrfID 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, std::span< int32_t > regs100)
Evaluate a newgrf callback for vehicles.
Functions for NewGRF engines.
void IndustryProductionCallback(Industry *ind, int reason)
Get the industry production callback and apply it to the industry.
bool IndustryTemporarilyRefusesCargo(Industry *ind, CargoType cargo_type)
Check whether an industry temporarily refuses to accept a certain cargo.
void TriggerIndustryRandomisation(Industry *ind, IndustryRandomTrigger trigger)
Trigger a random trigger for all industry tiles.
NewGRF handling of industry tiles.
@ PROP_VEHICLE_LOAD_AMOUNT
Loading speed.
void TriggerRoadStopRandomisation(BaseStation *st, TileIndex tile, StationRandomTrigger trigger, CargoType cargo_type)
Trigger road stop randomisation.
NewGRF definitions and structures for road stops.
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.
@ LoadUnload
Whenever cargo payment is made for a vehicle.
void TriggerStationRandomisation(BaseStation *st, TileIndex trigger_tile, StationRandomTrigger trigger, CargoType cargo_type)
Trigger station randomisation.
Header file for NewGRF stations.
Functions related to news.
void AddNewsItem(EncodedString &&headline, NewsType type, NewsStyle style, NewsFlags flags, NewsReference ref1={}, NewsReference ref2={}, std::unique_ptr< NewsAllocatedData > &&data=nullptr, AdviceType advice_type=AdviceType::Invalid)
Add a new newsitem to be shown.
Definition news_gui.cpp:919
@ Economy
Economic changes (recession, industry up/dowm).
Definition news_type.h:40
@ Normal
Normal news item. (Newspaper with text only).
Definition news_type.h:83
Functions related to objects.
void UpdateCompanyHQ(TileIndex tile, uint score)
Update the CompanyHQ to the state associated with the given score.
@ Menu
In the main menu.
Definition openttd.h:19
@ Transfer
Transfer all cargo onto the platform.
Definition order_type.h:70
@ NoUnload
Totally no unloading will be done.
Definition order_type.h:71
@ Unload
Force unloading all cargo onto the platform, possibly not getting paid.
Definition order_type.h:69
@ NoLoad
Do not load anything.
Definition order_type.h:81
@ FullLoadAny
Full load a single cargo of the consist.
Definition order_type.h:80
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.
Table of all default 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:503
Money SignalMaintenanceCost(uint32_t num)
Calculates the maintenance cost of a number of signals.
Definition rail.h:514
TrackBits GetTrackBits(Tile tile)
Gets the track bits of the given tile.
Definition rail_map.h:136
bool IsSignalPresent(Tile t, uint8_t signalbit)
Checks whether the given signals is present.
Definition rail_map.h:462
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:26
@ RAILTYPE_END
Used for iterations.
Definition rail_type.h:32
Declaration 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:107
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).
bool IsLevelCrossingTile(Tile t)
Return whether a tile is a level crossing tile.
Definition road_map.h:79
RoadType
The different roadtypes we support.
Definition road_type.h:24
@ ROADTYPE_END
Used for iterations.
Definition road_type.h:28
A number of safeguards to prevent using unsafe methods.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:61
ClientSettings _settings_client
The current settings for this game.
Definition settings.cpp:60
void AddTrackToSignalBuffer(TileIndex tile, Track track, Owner owner)
Add track to signal update buffer.
Definition signal.cpp:597
void UpdateSignalsInBuffer()
Update signals in buffer Called from 'outside'.
Definition signal.cpp:581
uint8_t SignalOnTrack(Track track)
Maps a Track to the bits that store the status of the two signals that can be present on the given tr...
Definition signal_func.h:48
Base class for signs.
Functions related to sound.
@ SND_14_CASHTILL
18 == 0x12 Income from cargo delivery
Definition sound_type.h:65
@ Industry
Source/destination is an industry.
Definition source_type.h:21
Money AirportMaintenanceCost(Owner owner)
Calculates the maintenance cost of all airports of a company.
Definition station.cpp:548
Base classes/functions for stations.
Functions related to stations.
Money StationMaintenanceCost(uint32_t num)
Calculates the maintenance cost of a number of station tiles.
StationID GetStationIndex(Tile t)
Get StationID from a tile.
Definition station_map.h:26
@ CargoTaken
Trigger station when cargo is completely taken.
@ VehicleLoads
Trigger platform when train loads/unloads.
@ CargoTaken
Trigger station when cargo is completely taken.
@ VehicleLoads
Trigger platform when train loads/unloads.
@ CargoTaken
Triggered when a cargo type is completely removed from the station (for all tiles at the same time).
Definition of base types and functions in a cross-platform compatible way.
StoryPage base class.
EncodedString GetEncodedString(StringID str)
Encode a string with no parameters into an encoded string.
Definition strings.cpp:89
Functions related to OTTD's strings.
StrongType::Typedef< uint32_t, struct StringIDTag, StrongType::Compare, StrongType::Integer > StringID
Numeric value that represents a string, independent of the selected language.
bool IsNormalAircraft() const
Check if the aircraft type is a normal flying device; eg not a rotor or a shadow.
Definition aircraft.h:123
Class to backup a specific variable and restore it upon destruction of this object to prevent stack v...
Class to backup a specific variable and restore it later.
void Restore()
Restore the variable.
TimerGameTick::Ticks current_order_time
How many ticks have passed since this order started.
VehicleFlags vehicle_flags
Used for gradual loading and other miscellaneous things (.
TimerGameTick::Ticks lateness_counter
How many ticks late (or early if negative) this vehicle is.
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.
Class for storing amounts of cargo.
Definition cargo_type.h:120
Container for cargo from the same location and time.
Definition cargopacket.h:40
Money GetFeederShare() const
Gets the amount of money already paid to earlier vehicles in the feeder chain.
uint GetDistance(TileIndex current_tile) const
Get the current distance the cargo has traveled.
uint16_t GetPeriodsInTransit() const
Gets the number of cargo aging periods this cargo has been in transit.
Source GetSource() const
Gets the source of the packet for subsidy purposes.
Helper class to perform the cargo payment.
void PayFinalDelivery(CargoType cargo, const CargoPacket *cp, uint count, TileIndex current_tile)
Handle payment for final delivery of the given cargo packet.
Definition economy.cpp:1218
~CargoPayment()
Execute the actual payment to the coffers of the company.
Definition economy.cpp:1184
StationID current_station
NOSAVE: The current station.
Money PayTransfer(CargoType cargo, const CargoPacket *cp, uint count, TileIndex current_tile)
Handle payment for transfer of the given cargo packet.
Definition economy.cpp:1236
Vehicle * front
The front vehicle to do the payment of.
Money visual_transfer
The transfer credits to be shown.
Money visual_profit
The visual profit to show.
Money route_profit
The amount of money to add/remove from the bank account.
Specification of a cargo type.
Definition cargotype.h:76
static CargoSpec * Get(size_t index)
Retrieve cargo details for the given cargo type.
Definition cargotype.h:140
static IterateWrapper Iterate(size_t from=0)
Returns an iterable ensemble of all valid CargoSpec.
Definition cargotype.h:239
Money current_payment
Payment rate scaled by inflation.
Definition cargotype.h:104
uint8_t transit_periods[2]
Values used to calculate timefactor for cargo payment alghoritm.
Definition cargotype.h:85
TownAcceptanceEffect town_acceptance_effect
The effect that delivering this cargo type has on towns. Also affects destination of subsidies.
Definition cargotype.h:88
CargoCallbackMasks callback_mask
Bitmask of cargo callbacks that have to be called.
Definition cargotype.h:91
bool IsValid() const
Tests for validity of this cargospec.
Definition cargotype.h:120
CargoArray delivered_cargo
The amount of delivered cargo.
TileIndex location_of_HQ
Northern tile of HQ; INVALID_TILE when there is none.
uint8_t months_of_bankruptcy
Number of months that the company is unable to pay its debts.
CompanyMask bankrupt_asked
which companies were asked about buying it?
int16_t bankrupt_timeout
If bigger than 0, amount of time to wait for an answer on an offer to buy this company.
CompanySettings settings
settings specific for each company
bool is_ai
If true, the company is (also) controlled by the computer (a NoAI program).
Money current_loan
Amount of money borrowed from the bank.
CompanyEconomyEntry cur_economy
Economic data of the company of this quarter.
std::array< CompanyEconomyEntry, MAX_HISTORY_QUARTERS > old_economy
Economic data of the company of the last MAX_HISTORY_QUARTERS quarters.
Money money
Money owned by the company.
uint8_t num_valid_stat_ent
Number of valid statistical entries in old_economy.
VehicleDefaultSettings vehicle
default settings for vehicles
Money GetMaxLoan() const
Calculate the max allowed loan for this company.
Data of the economy.
EngineMiscFlags misc_flags
Miscellaneous flags.
VehicleCallbackMasks callback_mask
Bitmask of vehicle callbacks that have to be called.
Action for finalizing a refit.
Definition economy.cpp:1435
std::span< const StationID > next_station
Next hops to reserve cargo for.
Definition economy.cpp:1438
CargoArray & consist_capleft
Capacities left in the consist.
Definition economy.cpp:1436
bool do_reserve
If the vehicle should reserve.
Definition economy.cpp:1439
FinalizeRefitAction(CargoArray &consist_capleft, Station *st, std::span< const StationID > next_station, bool do_reserve)
Create a finalizing action.
Definition economy.cpp:1448
bool operator()(Vehicle *v)
Reserve cargo from the station and update the remaining consist capacities with the vehicle's remaini...
Definition economy.cpp:1457
Station * st
Station to reserve cargo from.
Definition economy.cpp:1437
Dynamic data of a loaded NewGRF.
Definition newgrf.h:126
uint8_t grf_version
GRF version (See https://newgrf-specs.tt-wiki.net/wiki/Version_numbers#GRF_version).
Definition newgrf.h:129
PriceMultipliers price_base_multipliers
Price base multipliers as set by the grf.
Definition newgrf.h:171
Struct about goals, current and completed.
Definition goal_base.h:22
StationCargoList cargo
The cargo packets of cargo waiting in this station.
Stores station stats for a single cargo.
bool HasRating() const
Does this cargo have a rating at this station?
uint8_t last_speed
Maximum speed (up to 255) of the last vehicle that tried to load this cargo.
uint8_t last_age
Age in years (up to 255) of the last vehicle that tried to load this cargo.
uint8_t time_since_pickup
Number of rating-intervals (up to 255) since the last vehicle tried to load this cargo.
States status
Status of this cargo, see State.
@ Acceptance
Set when the station accepts the cargo currently for final deliveries.
@ EverAccepted
Set when a vehicle ever delivered cargo to the station for final delivery.
@ Rating
This indicates whether a cargo has a rating at the station.
@ AcceptedBigtick
Set when cargo was delivered for final delivery during the current STATION_ACCEPTANCE_TICKS interval.
@ CurrentMonth
Set when cargo was delivered for final delivery this month.
const GoodsEntryData & GetData() const
Get optional cargo packet/flow data.
GoodsEntryData & GetOrCreateData()
Get optional cargo packet/flow data.
uint AvailableCount() const
Returns sum of cargo still available for loading at the station.
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.
static void CountEngine(const Vehicle *v, int delta)
Update num_engines when adding/removing an engine.
static void UpdateAutoreplace(CompanyID company)
Update autoreplace_defined and autoreplace_finished of all statistics of a company.
Group data.
Definition group.h:76
Defines the data structure for constructing industry.
IndustryCallbackMasks callback_mask
Bitmask of industry callbacks that have to be called.
uint16_t input_cargo_multiplier[INDUSTRY_NUM_INPUTS][INDUSTRY_NUM_OUTPUTS]
Input cargo multipliers (multiply amount of incoming cargo for the produced cargoes).
Defines the internal data of a functional industry.
Definition industry.h:64
IndustryType type
type of industry.
Definition industry.h:117
Owner exclusive_supplier
Which company has exclusive rights to deliver cargo (INVALID_OWNER = anyone).
Definition industry.h:132
ProducedCargoes produced
produced cargo slots
Definition industry.h:112
AcceptedCargoes accepted
accepted cargo slots
Definition industry.h:113
uint8_t was_cargo_delivered
flag that indicate this has been the closest industry chosen for cargo delivery by a station....
Definition industry.h:121
AcceptedCargoes::iterator GetCargoAccepted(CargoType cargo)
Get accepted cargo slot for a specific cargo type.
Definition industry.h:204
Action to check if a vehicle has no stored cargo.
Definition economy.cpp:1362
bool operator()(const Vehicle *v)
Checks if the vehicle has stored cargo.
Definition economy.cpp:1368
static IterateWrapper Iterate()
Returns an iterable ensemble of all Tiles.
Definition map_func.h:366
static uint LogX()
Logarithm of the map size along the X side.
Definition map_func.h:243
static uint LogY()
Logarithm of the map size along the y side.
Definition map_func.h:253
bool IsType(OrderType type) const
Check whether this order is of the given type.
Definition order_base.h:66
CargoType GetRefitCargo() const
Get the cargo to to refit to.
Definition order_base.h:127
bool IsFullLoadOrder() const
Is this order a OrderLoadType::FullLoad or OrderLoadType::FullLoadAny?
Definition order_base.h:135
OrderUnloadType GetUnloadType() const
How must the consist be unloaded?
Definition order_base.h:151
OrderLoadType GetLoadType() const
How must the consist be loaded?
Definition order_base.h:145
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:282
bool IsRefit() const
Is this order a refit order.
Definition order_base.h:113
static Pool::IterateWrapper< Vehicle > Iterate(size_t from=0)
static Company * Get(auto index)
static Company * GetIfValid(auto index)
Refit preparation action.
Definition economy.cpp:1378
CargoTypes & refit_mask
Bitmask of possible refit cargoes.
Definition economy.cpp:1380
PrepareRefitAction(CargoArray &consist_capleft, CargoTypes &refit_mask)
Create a refit preparation action.
Definition economy.cpp:1387
CargoArray & consist_capleft
Capacities left in the consist.
Definition economy.cpp:1379
bool operator()(const Vehicle *v)
Prepares for refitting of a vehicle, subtracting its free capacity from consist_capleft and adding th...
Definition economy.cpp:1396
Action for returning reserved cargo.
Definition economy.cpp:1408
Station * st
Station to give the returned cargo to.
Definition economy.cpp:1409
bool operator()(Vehicle *v)
Return all reserved cargo from a vehicle.
Definition economy.cpp:1424
ReturnCargoAction(Station *st, StationID next_one)
Construct a cargo return action.
Definition economy.cpp:1417
StationID next_hop
Next hop the cargo should be assigned to.
Definition economy.cpp:1410
Data structure for storing how the score is computed for a single score id.
A location from where cargo can come from (or go to).
Definition source_type.h:32
SourceType type
Type of source_id.
Definition source_type.h:37
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
static Station * Get(auto index)
Station data structure.
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:292
IndustryList industries_near
Cached list of industries near the station that can accept cargo,.
CargoTypes always_accepted
Bitmask of always accepted cargo types (by houses, HQs, industry tiles when industry doesn't accept c...
std::array< GoodsEntry, NUM_CARGO > goods
Goods at this station.
Struct about stories, current and completed.
Definition story_base.h:157
Struct about subsidies, offered and awarded.
HistoryData< AcceptedHistory > history
Histor data of accepted cargo.
Definition town.h:118
Town data structure.
Definition town.h:64
AcceptedCargo & GetOrCreateCargoAccepted(CargoType cargo)
Get or create the storage for an accepted cargo.
Definition town.h:160
CompanyID exclusivity
which company has exclusivity
Definition town.h:87
uint8_t exclusive_counter
months till the exclusivity expires
Definition town.h:88
EnumIndexArray< TransportedCargoStat< uint16_t >, TownAcceptanceEffect, TownAcceptanceEffect::End > received
Cargo statistics about received cargotypes.
Definition town.h:133
'Train' is either a loco or a wagon.
Definition train.h:97
Train * other_multiheaded_part
Link between the two ends of a multiheaded engine.
Definition train.h:105
uint16_t cached_max_speed
Maximum speed of the consist (minimum of the max speed of all vehicles in the consist).
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.
CargoPayment * cargo_payment
The cargo payment we're currently in.
EngineID engine_type
The type of engine used for this vehicle.
int32_t z_pos
z coordinate.
const Engine * GetEngine() const
Retrieves the engine of the vehicle.
Definition vehicle.cpp:750
virtual TileIndex GetCargoTile() const
Tile to use for economic calculations when moving cargo into or out of this vehicle.
VehicleCargoList cargo
The cargo this vehicle is carrying.
uint16_t cargo_cap
total capacity
Vehicle * GetFirstEnginePart()
Get the first part of an articulated engine.
Money profit_this_year
Profit this year << 8, low 8 bits are fract.
bool HasArticulatedPart() const
Check if an engine has an articulated part.
VehStates vehstatus
Status.
void GetNextStoppingStation(std::vector< StationID > &next_station) const
Get the next station the vehicle will stop at.
CargoType cargo_type
type of cargo this vehicle is carrying
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Order current_order
The current order (+ status, like: loading).
Vehicle * Next() const
Get the next vehicle of this vehicle.
int32_t y_pos
y coordinate.
int32_t x_pos
x coordinate.
OrderList * orders
Pointer to the order list for this vehicle.
Vehicle * GetMovingFront() const
Get the moving front of the vehicle chain.
VehicleCache vcache
Cache of often used vehicle values.
GroundVehicleCache * GetGroundVehicleCache()
Access the ground vehicle cache of the vehicle.
Definition vehicle.cpp:3212
uint16_t load_unload_ticks
Ticks to wait before starting next cycle.
uint16_t cur_speed
current speed
TextEffectID fill_percent_te_id
a text-effect id to a loading indicator object
Vehicle * Previous() const
Get the previous vehicle of this vehicle.
TileIndex tile
Current tile index.
StationID last_station_visited
The last station we stopped at.
TimerGameCalendar::Year build_year
Year the vehicle has been built.
Owner owner
Which company owns the vehicle?
Representation of a waypoint.
void RebuildSubsidisedSourceAndDestinationCache()
Perform a full rebuild of the subsidies cache.
Definition subsidy.cpp:103
bool CheckSubsidised(CargoType cargo_type, CompanyID company, Source src, const Station *st)
Tests whether given delivery is subsidised and possibly awards the subsidy to delivering company.
Definition subsidy.cpp:493
Subsidy base class.
Functions related to subsidies.
static bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
bool IsTileOwner(Tile tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition tile_map.h:214
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > > TileIndex
The index/ID of a Tile.
Definition tile_type.h:92
static constexpr uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
@ Station
A tile of a station or airport.
Definition tile_type.h:54
@ Railway
A tile with railway.
Definition tile_type.h:50
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:44
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:1505
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.
bool IsCompanyBuildableVehicleType(VehicleType type)
Is the given vehicle type buildable by a company?
Functions related to the vehicle's GUIs.
WindowClass GetWindowClassForVehicleType(VehicleType vt)
Get WindowClass for vehicle list of given vehicle type.
Definition vehicle_gui.h:96
@ Ship
Ship vehicle type.
@ Aircraft
Aircraft vehicle type.
@ Road
Road vehicle type.
@ Train
Train vehicle type.
@ NewCargo
Affected vehicle only: Vehicle is loaded with cargo, after it was empty.
@ Empty
Front vehicle only: Entire consist is empty.
EnumIndexArray< T, VehicleType, Tend > VehicleTypeIndexArray
Array with VehicleType as index.
Functions related to water management.
Money CanalMaintenanceCost(uint32_t num)
Calculates the maintenance cost of a number of canal tiles.
Definition water.h:53
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:1291
void SetWindowClassesDirty(WindowClass cls)
Mark all windows of a particular class as dirty (in need of repainting).
Definition window.cpp:3285
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:3377
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting).
Definition window.cpp:3255
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:3395