OpenTTD Source 20261112-master-gbcbec5e63f
company_cmd.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 "company_base.h"
12#include "company_func.h"
13#include "company_gui.h"
14#include "town.h"
15#include "news_func.h"
16#include "command_func.h"
17#include "network/network.h"
21#include "ai/ai.hpp"
22#include "ai/ai_instance.hpp"
23#include "ai/ai_config.hpp"
25#include "window_func.h"
26#include "strings_func.h"
27#include "sound_func.h"
28#include "rail.h"
29#include "core/pool_func.hpp"
31#include "settings_func.h"
32#include "vehicle_base.h"
33#include "vehicle_func.h"
34#include "smallmap_gui.h"
35#include "game/game.hpp"
36#include "goal_base.h"
37#include "story_base.h"
38#include "company_cmd.h"
39#include "script/api/script_event_types.hpp"
40#include "timer/timer.h"
43#include "timer/timer_window.h"
44#include "road_gui.h"
45
48
49#include "table/strings.h"
50#include "table/company_face.h"
51
52#include "safeguards.h"
53
54void ClearEnginesHiddenFlagOfCompany(CompanyID cid);
55void UpdateObjectColours(const Company *c);
56
57CompanyID _local_company;
62
63CompanyPool _company_pool("Company");
65
66
72Company::Company(CompanyID index, StringID name_1, bool is_ai) : CompanyPool::PoolItem<&_company_pool>(index)
73{
74 this->name_1 = name_1;
75 this->is_ai = is_ai;
76 this->terraform_limit = (uint32_t)_settings_game.construction.terraform_frame_burst << 16;
77 this->clear_limit = (uint32_t)_settings_game.construction.clear_frame_burst << 16;
78 this->tree_limit = (uint32_t)_settings_game.construction.tree_frame_burst << 16;
79 this->build_object_limit = (uint32_t)_settings_game.construction.build_object_frame_burst << 16;
80
81 InvalidateWindowData(WindowClass::PerformanceDetail, 0, CompanyID::Invalid());
82}
83
86{
87 if (CleaningPool()) return;
88
90}
91
97{
98 InvalidateWindowData(WindowClass::GraphLegend, 0, static_cast<int>(index));
99 InvalidateWindowData(WindowClass::PerformanceDetail, 0, static_cast<int>(index));
100 InvalidateWindowData(WindowClass::CompanyLeague, 0, 0);
101 InvalidateWindowData(WindowClass::LinkGraphLegend, 0);
102 /* If the currently shown error message has this company in it, then close it. */
103 InvalidateWindowData(WindowClass::ErrorMessage, 0);
104}
105
111{
112 if (this->max_loan == COMPANY_MAX_LOAN_DEFAULT) return _economy.max_loan;
113 return this->max_loan;
114}
115
123void SetLocalCompany(CompanyID new_company, bool switching_game)
124{
125 /* company could also be COMPANY_SPECTATOR or OWNER_NONE */
126 assert(Company::IsValidID(new_company) || new_company == COMPANY_SPECTATOR || new_company == OWNER_NONE);
127
128 /* If actually changing to another company, several windows need closing */
129 bool switching_company = _local_company != new_company;
130
131 /* Delete the chat window, if you were team chatting. */
132 if (switching_company) InvalidateWindowData(WindowClass::NetworkChat, NetworkChatDestinationType::Team, _local_company);
133
134 assert(IsLocalCompany());
135
136 _current_company = _local_company = new_company;
137
138 if (switching_company) {
139 InvalidateWindowClassesData(WindowClass::Company);
140 InvalidateWindowClassesData(WindowClass::VehicleView);
141 /* Delete any construction windows... */
143 }
144
145 if (switching_company || switching_game) {
146 /* Update the default rail and road types */
149 }
150
151 if (!switching_game) {
152 /* ... and redraw the whole screen. */
154 InvalidateWindowClassesData(WindowClass::SignList, -1);
155 InvalidateWindowClassesData(WindowClass::GoalList);
156 InvalidateWindowClassesData(WindowClass::CompanyLivery, -1);
157 ResetVehicleColourMap();
158 }
159}
160
171
177PaletteID GetCompanyPalette(CompanyID company)
178{
179 return GetColourPalette(_company_colours[company]);
180}
181
188void DrawCompanyIcon(CompanyID c, int x, int y)
189{
191}
192
200{
201 if (cmf.style >= GetNumCompanyManagerFaceStyles()) return false;
202
203 /* Test if each enabled part is valid. */
204 FaceVars vars = GetCompanyManagerFaceVars(cmf.style);
205 for (uint var : SetBitIterator(GetActiveFaceVars(cmf, vars))) {
206 if (!vars[var].IsValid(cmf)) return false;
207 }
208
209 return true;
210}
211
213
220{
221 CompanyID cid = company->index;
223}
224
228static const IntervalTimer<TimerWindow> invalidate_company_windows_interval(std::chrono::milliseconds(1), [](auto) {
229 for (CompanyID cid : _dirty_company_finances) {
230 if (cid == _local_company) SetWindowWidgetDirty(WindowClass::Statusbar, 0, WID_S_RIGHT);
231 Window *w = FindWindowById(WindowClass::Finances, cid);
232 if (w != nullptr) {
238 }
239 SetWindowWidgetDirty(WindowClass::Company, cid, WID_C_DESC_COMPANY_VALUE);
240 }
242});
243
251Money GetAvailableMoney(CompanyID company)
252{
253 if (_settings_game.difficulty.infinite_money) return INT64_MAX;
254 if (!Company::IsValidID(company)) return INT64_MAX;
255 return Company::Get(company)->money;
256}
257
269
277{
278 if (cost.GetCost() <= 0) return true;
279 if (_settings_game.difficulty.infinite_money) return true;
280
282 if (c != nullptr && cost.GetCost() > c->money) {
283 cost.MakeError(STR_ERROR_NOT_ENOUGH_CASH_REQUIRES_CURRENCY);
284 if (IsLocalCompany()) {
285 cost.SetEncodedMessage(GetEncodedString(STR_ERROR_NOT_ENOUGH_CASH_REQUIRES_CURRENCY, cost.GetCost()));
286 }
287 return false;
288 }
289 return true;
290}
291
297static void SubtractMoneyFromCompany(Company *c, const CommandCost &cost)
298{
299 using ExpensesTypes = EnumBitSet<ExpensesType, uint16_t>;
300 static constexpr ExpensesTypes EXPENSESTYPES_INCOME{
305 };
306 static constexpr ExpensesTypes EXPENSESTYPES_EXPENSES{
313 };
314
315 if (cost.GetCost() == 0) return;
316 assert(cost.GetExpensesType() != ExpensesType::Invalid);
317
318 c->money -= cost.GetCost();
319 c->yearly_expenses[0][cost.GetExpensesType()] += cost.GetCost();
320
321 if (EXPENSESTYPES_INCOME.Test(cost.GetExpensesType())) {
322 c->cur_economy.income -= cost.GetCost();
323 } else if (EXPENSESTYPES_EXPENSES.Test(cost.GetExpensesType())) {
324 c->cur_economy.expenses -= cost.GetCost();
325 }
326
328}
329
335void SubtractMoneyFromCompany(CompanyID company, const CommandCost &cost)
336{
337 Company *c = Company::GetIfValid(company);
338 if (c != nullptr) SubtractMoneyFromCompany(c, cost);
339}
340
346void SubtractMoneyFromCompanyFract(CompanyID company, const CommandCost &cst)
347{
348 Company *c = Company::Get(company);
349 uint8_t m = c->money_fraction;
350 Money cost = cst.GetCost();
351
352 c->money_fraction = m - (uint8_t)cost;
353 cost >>= 8;
354 if (c->money_fraction > m) cost++;
355 if (cost != 0) SubtractMoneyFromCompany(c, CommandCost(cst.GetExpensesType(), cost));
356}
357
358static constexpr void UpdateLandscapingLimit(uint32_t &limit, uint64_t per_64k_frames, uint64_t burst)
359{
360 limit = static_cast<uint32_t>(std::min<uint64_t>(limit + per_64k_frames, burst << 16));
361}
362
365{
366 for (Company *c : Company::Iterate()) {
367 UpdateLandscapingLimit(c->terraform_limit, _settings_game.construction.terraform_per_64k_frames, _settings_game.construction.terraform_frame_burst);
368 UpdateLandscapingLimit(c->clear_limit, _settings_game.construction.clear_per_64k_frames, _settings_game.construction.clear_frame_burst);
369 UpdateLandscapingLimit(c->tree_limit, _settings_game.construction.tree_per_64k_frames, _settings_game.construction.tree_frame_burst);
370 UpdateLandscapingLimit(c->build_object_limit, _settings_game.construction.build_object_per_64k_frames, _settings_game.construction.build_object_frame_burst);
371 }
372}
373
381std::array<StringParameter, 2> GetParamsForOwnedBy(Owner owner, TileIndex tile)
382{
383 if (owner == OWNER_TOWN) {
384 assert(tile != 0);
385 const Town *t = ClosestTownFromTile(tile, UINT_MAX);
386 return {STR_TOWN_NAME, t->index};
387 }
388
389 if (!Company::IsValidID(owner)) {
390 return {STR_COMPANY_SOMEONE, std::monostate{}};
391 }
392
393 return {STR_COMPANY_NAME, owner};
394}
395
405{
406 assert(owner < OWNER_END);
407 assert(owner != OWNER_TOWN || tile != 0);
408
409 if (owner == _current_company) return CommandCost();
410
411 CommandCost error{STR_ERROR_OWNED_BY};
412 if (IsLocalCompany()) {
413 auto params = GetParamsForOwnedBy(owner, tile);
414 error.SetEncodedMessage(GetEncodedStringWithArgs(STR_ERROR_OWNED_BY, params));
415 if (owner != OWNER_TOWN) error.SetErrorOwner(owner);
416 }
417 return error;
418}
419
428{
429 return CheckOwnership(GetTileOwner(tile), tile);
430}
431
441static bool SetCompanyName(std::span<const std::string> other_names, Company *c, const Town *t, StringID str, uint32_t strp)
442{
443 assert(c != nullptr);
444 assert(t != nullptr);
445
446 /* Name must not be too long. */
447 std::string name = GetString(str, strp);
448 if (Utf8StringLength(name) >= MAX_LENGTH_COMPANY_NAME_CHARS) return false;
449
450 /* No companies must have this name already. */
451 if (std::ranges::find(other_names, name) != other_names.end()) return false;
452
453 c->name_1 = str;
454 c->name_2 = strp;
455
457 AI::BroadcastNewEvent(new ScriptEventCompanyRenamed(c->index, name));
458 Game::NewEvent(new ScriptEventCompanyRenamed(c->index, name));
459
460 if (!c->is_ai) return true;
461
462 auto cni = std::make_unique<CompanyNewsInformation>(STR_NEWS_COMPANY_LAUNCH_TITLE, c);
463 EncodedString headline = GetEncodedString(STR_NEWS_COMPANY_LAUNCH_DESCRIPTION, cni->company_name, t->index);
464 AddNewsItem(std::move(headline),
466
467 return true;
468}
469
475{
476 if (c->name_1 != STR_SV_UNNAMED) return;
477 if (c->last_build_coordinate == 0) return;
478
479 /* Collect existing company names. */
480 std::vector<std::string> other_names;
481 for (const Company *cc : Company::Iterate()) {
482 if (cc != c) other_names.emplace_back(GetString(STR_COMPANY_NAME, cc->index));
483 }
484
485 const Town *t = ClosestTownFromTile(c->last_build_coordinate, UINT_MAX);
486
487 if (t->name.empty() && IsInsideMM(t->townnametype, SPECSTR_TOWNNAME_START, SPECSTR_TOWNNAME_END)) {
489 }
490
492 if (SetCompanyName(other_names, c, t, SPECSTR_ANDCO_NAME, c->president_name_2)) return;
493 }
494
495 for (;;) {
496 if (SetCompanyName(other_names, c, t, SPECSTR_ANDCO_NAME, Random())) return;
497 }
498}
499
501static const EnumIndexArray<uint8_t, Colours, Colours::End> _colour_sort{2, 2, 3, 2, 3, 2, 3, 2, 3, 2, 2, 2, 3, 1, 1, 1};
503static const std::initializer_list<Colours> _similar_colour[to_underlying(Colours::End)] = {
504 {Colours::Blue, Colours::LightBlue }, // Colours::DarkBlue
505 {Colours::Green, Colours::DarkGreen }, // Colours::PaleGreen
506 {}, // Colours::Pink
507 {Colours::Orange}, // Colours::Yellow
508 {}, // Colours::Red
509 {Colours::DarkBlue, Colours::Blue }, // Colours::LightBlue
510 {Colours::PaleGreen, Colours::DarkGreen }, // Colours::Green
511 {Colours::PaleGreen, Colours::Green }, // Colours::DarkGreen
512 {Colours::DarkBlue, Colours::LightBlue }, // Colours::Blue
513 {Colours::Brown, Colours::Orange }, // Colours::Cream
514 {Colours::Purple}, // Colours::Mauve
515 {Colours::Mauve}, // Colours::Purple
516 {Colours::Yellow, Colours::Cream }, // Colours::Orange
517 {Colours::Cream}, // Colours::Brown
518 {Colours::White}, // Colours::Grey
519 {Colours::Grey}, // Colours::White
520};
521
527{
528 /* Initialize colour table. */
529 std::vector<Colours> colours(to_underlying(Colours::End));
530 std::iota(colours.begin(), colours.end(), Colours::Begin);
531
532 /* And randomize it */
533 for (uint i = 0; i < 100; i++) {
534 uint r = Random();
535 std::swap(colours[GB(r, 0, 4)], colours[GB(r, 4, 4)]);
536 }
537
538 /* Sort it according to the values in _colour_sort. */
539 std::ranges::stable_sort(colours, std::greater{}, [](auto &i) { return _colour_sort[i]; });
540
541 /* Move the colours that look similar to each company's colour to the side */
542 for (const Company *c : Company::Iterate()) {
543 /* This company's colour is not available at all. */
544 std::erase(colours, c->colour);
545
546 for (Colours similar : _similar_colour[to_underlying(c->colour)]) {
547 auto it = std::ranges::find(colours, similar);
548 if (it != colours.end()) std::rotate(it, it + 1, colours.end());
549 }
550 }
551
552 /* Return the first available colour */
553 return colours.at(0);
554}
555
563static bool SetPresidentName(std::span<const std::string> other_names, Company *c, uint32_t seed)
564{
565 assert(c != nullptr);
566
568 c->president_name_2 = seed;
569
570 /* President name must not be too long. */
571 std::string name = GetString(STR_PRESIDENT_NAME, c->index);
572 if (Utf8StringLength(name) >= MAX_LENGTH_PRESIDENT_NAME_CHARS) return false;
573
574 /* No presidents must have this name already. */
575 if (std::ranges::find(other_names, name) != other_names.end()) return false;
576
577 return true;
578}
579
585{
586 /* Collect existing president names. */
587 std::vector<std::string> other_names;
588 for (const Company *cc : Company::Iterate()) {
589 if (cc != c) other_names.emplace_back(GetString(STR_PRESIDENT_NAME, cc->index));
590 }
591
592 for (;;) {
593 if (SetPresidentName(other_names, c, Random())) return;
594 }
595}
596
603{
605 c->livery[scheme].in_use.Reset();
606 c->livery[scheme].colour1 = c->colour;
607 c->livery[scheme].colour2 = c->colour;
608 }
609
610 for (Group *g : Group::Iterate()) {
611 if (g->owner == c->index) {
612 g->livery.in_use.Reset();
613 g->livery.colour1 = c->colour;
614 g->livery.colour2 = c->colour;
615 }
616 }
617}
618
626Company *DoStartupNewCompany(bool is_ai, CompanyID company = CompanyID::Invalid())
627{
628 if (!Company::CanAllocateItem()) return nullptr;
629
630 /* we have to generate colour before this company is valid */
632
633 Company *c;
634 if (company == CompanyID::Invalid()) {
635 c = Company::Create(STR_SV_UNNAMED, is_ai);
636 } else {
637 if (Company::IsValidID(company)) return nullptr;
638 c = Company::CreateAtIndex(company, STR_SV_UNNAMED, is_ai);
639 }
640
641 c->colour = colour;
642
644 _company_colours[c->index] = c->colour;
645
646 /* Scale the initial loan based on the inflation rounded down to the loan interval. The maximum loan has already been inflation adjusted. */
647 c->money = c->current_loan = std::min<int64_t>((INITIAL_LOAN * _economy.inflation_prices >> 16) / LOAN_INTERVAL * LOAN_INTERVAL, _economy.max_loan);
648
653
654 /* If starting a player company in singleplayer and a favourite company manager face is selected, choose it. Otherwise, use a random face.
655 * In a network game, we'll choose the favourite face later in CmdCompanyCtrl to sync it to all clients. */
656 bool randomise_face = true;
657 if (!_company_manager_face.empty() && !is_ai && !_networking) {
659 if (cmf.has_value()) {
660 randomise_face = false;
661 c->face = std::move(*cmf);
662 }
663 }
664 if (randomise_face) RandomiseCompanyManagerFace(c->face, _random);
665
668
670
671 SetWindowDirty(WindowClass::GraphLegend, 0);
672 InvalidateWindowData(WindowClass::NetworkClientList, 0);
673 InvalidateWindowData(WindowClass::LinkGraphLegend, 0);
675 InvalidateWindowData(WindowClass::SmallMap, 0, 1);
676
677 if (is_ai && (!_networking || _network_server)) AI::StartNew(c->index);
678
679 AI::BroadcastNewEvent(new ScriptEventCompanyNew(c->index), c->index);
680 Game::NewEvent(new ScriptEventCompanyNew(c->index));
681
682 return c;
683}
684
687 if (_game_mode == GameMode::Menu || !AI::CanStartNew()) return;
688 if (_networking && Company::GetNumItems() >= _settings_client.network.max_companies) return;
689 if (_settings_game.difficulty.competitors_interval == 0) return;
690
691 /* count number of competitors */
692 uint8_t n = 0;
693 for (const Company *c : Company::Iterate()) {
694 if (c->is_ai) n++;
695 }
696
697 if (n >= _settings_game.difficulty.max_no_competitors) return;
698
699 /* Send a command to all clients to start up a new AI.
700 * Works fine for Multiplayer and Singleplayer */
701 Command<Commands::CompanyControl>::Post(CompanyCtrlAction::NewAI, CompanyID::Invalid(), CompanyRemoveReason::None, ClientID::Invalid);
702});
703
706{
707 /* Ensure the timeout is aborted, so it doesn't fire based on information of the last game. */
709}
710
716
723bool CheckTakeoverVehicleLimit(CompanyID cbig, CompanyID csmall)
724{
725 const Company *c1 = Company::Get(cbig);
726 const Company *c2 = Company::Get(csmall);
727
728 /* Do the combined vehicle counts stay within the limits? */
729 return c1->group_all[VehicleType::Train].num_vehicle + c2->group_all[VehicleType::Train].num_vehicle <= _settings_game.vehicle.max_trains &&
730 c1->group_all[VehicleType::Road].num_vehicle + c2->group_all[VehicleType::Road].num_vehicle <= _settings_game.vehicle.max_roadveh &&
731 c1->group_all[VehicleType::Ship].num_vehicle + c2->group_all[VehicleType::Ship].num_vehicle <= _settings_game.vehicle.max_ships &&
732 c1->group_all[VehicleType::Aircraft].num_vehicle + c2->group_all[VehicleType::Aircraft].num_vehicle <= _settings_game.vehicle.max_aircraft;
733}
734
745{
746 /* Amount of time out for each company to take over a company;
747 * Timeout is a quarter (3 months of 30 days) divided over the
748 * number of companies. The minimum number of days in a quarter
749 * is 90: 31 in January, 28 in February and 31 in March.
750 * Note that the company going bankrupt can't buy itself. */
751 static const int TAKE_OVER_TIMEOUT = 3 * 30 * Ticks::DAY_TICKS / (MAX_COMPANIES - 1);
752
753 assert(c->bankrupt_asked.Any());
754
755 /* We're currently asking some company to buy 'us' */
756 if (c->bankrupt_timeout != 0) {
757 c->bankrupt_timeout -= MAX_COMPANIES;
758 if (c->bankrupt_timeout > 0) return;
759 c->bankrupt_timeout = 0;
760
761 return;
762 }
763
764 /* Did we ask everyone for bankruptcy? If so, bail out. */
765 if (c->bankrupt_asked.All()) return;
766
767 Company *best = nullptr;
768 int32_t best_performance = -1;
769
770 /* Ask the company with the highest performance history first */
771 for (Company *c2 : Company::Iterate()) {
772 if (c2->bankrupt_asked.None() && // Don't ask companies going bankrupt themselves
773 !c->bankrupt_asked.Test(c2->index) &&
774 best_performance < c2->old_economy[1].performance_history &&
775 CheckTakeoverVehicleLimit(c2->index, c->index)) {
776 best_performance = c2->old_economy[1].performance_history;
777 best = c2;
778 }
779 }
780
781 /* Asked all companies? */
782 if (best_performance == -1) {
783 c->bankrupt_asked.Set();
784 return;
785 }
786
787 c->bankrupt_asked.Set(best->index);
788
789 c->bankrupt_timeout = TAKE_OVER_TIMEOUT;
790
791 AI::NewEvent(best->index, new ScriptEventCompanyAskMerger(c->index, c->bankrupt_value));
792 if (IsInteractiveCompany(best->index)) {
793 ShowBuyCompanyDialog(c->index, false);
794 }
795}
796
799{
800 if (_game_mode == GameMode::Editor) return;
801
803 if (c != nullptr) {
804 if (c->name_1 != 0) GenerateCompanyName(c);
806 }
807
808 if (_new_competitor_timeout.HasFired() && _game_mode != GameMode::Menu && AI::CanStartNew()) {
809 int32_t timeout = _settings_game.difficulty.competitors_interval * 60 * Ticks::TICKS_PER_SECOND;
810 /* If the interval is zero, start as many competitors as needed then check every ~10 minutes if a company went bankrupt and needs replacing. */
811 if (timeout == 0) {
812 /* count number of competitors */
813 uint8_t num_ais = 0;
814 for (const Company *cc : Company::Iterate()) {
815 if (cc->is_ai) num_ais++;
816 }
817
818 size_t num_companies = Company::GetNumItems();
819 for (auto i = 0; i < _settings_game.difficulty.max_no_competitors; i++) {
820 if (_networking && num_companies++ >= _settings_client.network.max_companies) break;
821 if (num_ais++ >= _settings_game.difficulty.max_no_competitors) break;
822 Command<Commands::CompanyControl>::Post(CompanyCtrlAction::NewAI, CompanyID::Invalid(), {}, ClientID::Invalid);
823 }
824 timeout = 10 * 60 * Ticks::TICKS_PER_SECOND;
825 }
826 /* Randomize a bit when the AI is actually going to start; ranges from 87.5% .. 112.5% of indicated value. */
827 timeout += ScriptObject::GetRandomizer(OWNER_NONE).Next(timeout / 4) - timeout / 8;
828
829 _new_competitor_timeout.Reset({ TimerGameTick::Priority::CompetitorTimeout, static_cast<uint>(std::max(1, timeout)) });
830 }
831
832 _cur_company_tick_index = (_cur_company_tick_index + 1) % MAX_COMPANIES;
833}
834
839static const IntervalTimer<TimerGameEconomy> _economy_companies_yearly({TimerGameEconomy::Trigger::Year, TimerGameEconomy::Priority::Company}, [](auto)
840{
841 /* Copy statistics */
842 for (Company *c : Company::Iterate()) {
843 /* Move expenses to previous years. */
844 std::rotate(std::rbegin(c->yearly_expenses), std::rbegin(c->yearly_expenses) + 1, std::rend(c->yearly_expenses));
845 c->yearly_expenses[0].fill(0);
846 InvalidateWindowData(WindowClass::Finances, c->index);
847 }
848
849 if (_settings_client.gui.show_finances && _local_company != COMPANY_SPECTATOR) {
852 if (c->num_valid_stat_ent > 5 && c->old_economy[0].performance_history < c->old_economy[4].performance_history) {
853 if (_settings_client.sound.new_year) SndPlayFx(SND_01_BAD_YEAR);
854 } else {
855 if (_settings_client.sound.new_year) SndPlayFx(SND_00_GOOD_YEAR);
856 }
857 }
858});
859
867{
868 this->company_name = GetString(STR_COMPANY_NAME, c->index);
869
870 if (other != nullptr) {
871 this->other_company_name = GetString(STR_COMPANY_NAME, other->index);
872 c = other;
873 }
874
875 this->president_name = GetString(STR_PRESIDENT_NAME_MANAGER, c->index);
876
877 this->title = title;
878 this->colour = c->colour;
879 this->face = c->face;
880
881}
882
887void CompanyAdminUpdate(const Company *company)
888{
890}
891
897void CompanyAdminRemove(CompanyID company_id, CompanyRemoveReason reason)
898{
899 if (_network_server) NetworkAdminCompanyRemove(company_id, static_cast<AdminCompanyRemoveReason>(reason));
900}
901
911CommandCost CmdCompanyCtrl(DoCommandFlags flags, CompanyCtrlAction cca, CompanyID company_id, CompanyRemoveReason reason, ClientID client_id)
912{
913 InvalidateWindowData(WindowClass::CompanyLeague, 0, 0);
914
915 switch (cca) {
916 case CompanyCtrlAction::New: { // Create a new company
917 /* This command is only executed in a multiplayer game */
918 if (!_networking) return CMD_ERROR;
919
920 /* Has the network client a correct ClientID? */
921 if (!flags.Test(DoCommandFlag::Execute)) return CommandCost();
922
924
925 /* Delete multiplayer progress bar */
926 CloseWindowById(WindowClass::NetworkStatus, NetworkStatusWindowNumber::Join);
927
928 Company *c = DoStartupNewCompany(false);
929
930 /* A new company could not be created, revert to being a spectator */
931 if (c == nullptr) {
932 /* We check for "ci != nullptr" as a client could have left by
933 * the time we execute this command. */
934 if (_network_server && ci != nullptr) {
937 }
938 break;
939 }
940
943
944 /* This is the client (or non-dedicated server) who wants a new company */
945 if (client_id == _network_own_client_id) {
947 SetLocalCompany(c->index);
948
949 /*
950 * If a favourite company manager face is selected, choose it. Otherwise, use a random face.
951 * Because this needs to be synchronised over the network, only the client knows
952 * its configuration and we are currently in the execution of a command, we have
953 * to circumvent the normal ::Post logic for commands and just send the command.
954 */
955 if (!_company_manager_face.empty()) {
957 if (cmf.has_value()) {
958 Command<Commands::SetCompanyManagerFace>::SendNet(STR_NULL, c->index, cmf->style, cmf->bits);
959 }
960 }
961
962 /* Now that we have a new company, broadcast our company settings to
963 * all clients so everything is in sync */
965
967 }
968 break;
969 }
970
971 case CompanyCtrlAction::NewAI: { // Make a new AI company
972 if (company_id != CompanyID::Invalid() && company_id >= MAX_COMPANIES) return CMD_ERROR;
973
974 /* For network games, company deletion is delayed. */
975 if (!_networking && company_id != CompanyID::Invalid() && Company::IsValidID(company_id)) return CMD_ERROR;
976
977 if (!flags.Test(DoCommandFlag::Execute)) return CommandCost();
978
979 /* For network game, just assume deletion happened. */
980 assert(company_id == CompanyID::Invalid() || !Company::IsValidID(company_id));
981
982 Company *c = DoStartupNewCompany(true, company_id);
983 if (c != nullptr) {
985 NetworkServerNewCompany(c, nullptr);
986 }
987 break;
988 }
989
990 case CompanyCtrlAction::Delete: { // Delete a company
991 if (reason >= CompanyRemoveReason::End) return CMD_ERROR;
992
993 /* We can't delete the last existing company in singleplayer mode. */
994 if (!_networking && Company::GetNumItems() == 1) return CMD_ERROR;
995
996 Company *c = Company::GetIfValid(company_id);
997 if (c == nullptr) return CMD_ERROR;
998
999 if (!flags.Test(DoCommandFlag::Execute)) return CommandCost();
1000
1001 /* Show the bankrupt news */
1002 auto cni = std::make_unique<CompanyNewsInformation>(STR_NEWS_COMPANY_BANKRUPT_TITLE, c);
1003 EncodedString headline = GetEncodedString(STR_NEWS_COMPANY_BANKRUPT_DESCRIPTION, cni->company_name);
1004 AddCompanyNewsItem(std::move(headline), std::move(cni));
1005
1006 /* Remove the company */
1008 if (c->is_ai) AI::Stop(c->index);
1009
1010 CompanyID c_index = c->index;
1011 delete c;
1012 AI::BroadcastNewEvent(new ScriptEventCompanyBankrupt(c_index));
1013 Game::NewEvent(new ScriptEventCompanyBankrupt(c_index));
1014 CompanyAdminRemove(c_index, (CompanyRemoveReason)reason);
1015
1016 if (StoryPage::GetNumItems() == 0 || Goal::GetNumItems() == 0) InvalidateWindowData(WindowClass::MainToolbar, 0);
1017 InvalidateWindowData(WindowClass::NetworkClientList, 0);
1018
1019 break;
1020 }
1021
1022 default: return CMD_ERROR;
1023 }
1024
1025 InvalidateWindowClassesData(WindowClass::GameOptions);
1026 InvalidateWindowClassesData(WindowClass::ScriptSettings);
1027 InvalidateWindowClassesData(WindowClass::ScriptList);
1028
1029 return CommandCost();
1030}
1031
1032static bool ExecuteAllowListCtrlAction(CompanyAllowListCtrlAction action, Company *c, const std::string &public_key)
1033{
1034 switch (action) {
1036 return c->allow_list.Add(public_key);
1037
1039 return c->allow_list.Remove(public_key);
1040
1042 if (c->allow_any) return false;
1043 c->allow_any = true;
1044 return true;
1045
1047 if (!c->allow_any) return false;
1048 c->allow_any = false;
1049 return true;
1050
1051 default:
1052 NOT_REACHED();
1053 }
1054}
1055
1064{
1066 if (c == nullptr) return CMD_ERROR;
1067
1068 switch (action) {
1071 /* The public key length includes the '\0'. */
1072 if (public_key.size() != NETWORK_PUBLIC_KEY_LENGTH - 1) return CMD_ERROR;
1073 break;
1074
1077 if (public_key.size() != 0) return CMD_ERROR;
1078 break;
1079
1080 default:
1081 return CMD_ERROR;
1082 }
1083
1084 if (flags.Test(DoCommandFlag::Execute)) {
1085 if (ExecuteAllowListCtrlAction(action, c, public_key)) {
1086 InvalidateWindowData(WindowClass::NetworkClientList, 0);
1087 SetWindowDirty(WindowClass::Company, _current_company);
1088 }
1089 }
1090
1091 return CommandCost();
1092}
1093
1101CommandCost CmdSetCompanyManagerFace(DoCommandFlags flags, uint style, uint32_t bits)
1102{
1103 CompanyManagerFace tmp_face{style, bits, {}};
1104 if (!IsValidCompanyManagerFace(tmp_face)) return CMD_ERROR;
1105
1106 if (flags.Test(DoCommandFlag::Execute)) {
1108 SetCompanyManagerFaceStyle(cmf, style);
1109 cmf.bits = tmp_face.bits;
1110
1112 }
1113 return CommandCost();
1114}
1115
1122{
1124 if (!c->livery[i].in_use.Test(Livery::Flag::Primary)) c->livery[i].colour1 = c->livery[LiveryScheme::Default].colour1;
1125 if (!c->livery[i].in_use.Test(Livery::Flag::Secondary)) c->livery[i].colour2 = c->livery[LiveryScheme::Default].colour2;
1126 }
1128}
1129
1139{
1140 if (scheme >= LiveryScheme::End || (colour >= Colours::End && colour != Colours::Invalid)) return CMD_ERROR;
1141
1142 /* Default scheme can't be reset to invalid. */
1143 if (scheme == LiveryScheme::Default && colour == Colours::Invalid) return CMD_ERROR;
1144
1146
1147 /* Ensure no two companies have the same primary colour */
1148 if (scheme == LiveryScheme::Default && primary) {
1149 for (const Company *cc : Company::Iterate()) {
1150 if (cc != c && cc->colour == colour) return CMD_ERROR;
1151 }
1152 }
1153
1154 if (flags.Test(DoCommandFlag::Execute)) {
1155 if (primary) {
1156 if (scheme != LiveryScheme::Default) c->livery[scheme].in_use.Set(Livery::Flag::Primary, colour != Colours::Invalid);
1157 if (colour == Colours::Invalid) colour = c->livery[LiveryScheme::Default].colour1;
1158 c->livery[scheme].colour1 = colour;
1159
1160 /* If setting the first colour of the default scheme, adjust the
1161 * original and cached company colours too. */
1162 if (scheme == LiveryScheme::Default) {
1165 c->colour = colour;
1167 }
1168 } else {
1169 if (scheme != LiveryScheme::Default) c->livery[scheme].in_use.Set(Livery::Flag::Secondary, colour != Colours::Invalid);
1170 if (colour == Colours::Invalid) colour = c->livery[LiveryScheme::Default].colour2;
1171 c->livery[scheme].colour2 = colour;
1172
1173 if (scheme == LiveryScheme::Default) {
1175 }
1176 }
1177
1178 if (c->livery[scheme].in_use.Any({Livery::Flag::Primary, Livery::Flag::Secondary})) {
1179 /* If enabling a scheme, set the default scheme to be in use too */
1180 c->livery[LiveryScheme::Default].in_use.Set(Livery::Flag::Primary);
1181 } else {
1182 /* Else loop through all schemes to see if any are left enabled.
1183 * If not, disable the default scheme too. */
1185 for (LiveryScheme other_scheme : EnumRange(LiveryScheme::End)) {
1186 if (c->livery[other_scheme].in_use.Any({Livery::Flag::Primary, Livery::Flag::Secondary})) {
1187 c->livery[LiveryScheme::Default].in_use.Set(Livery::Flag::Primary);
1188 break;
1189 }
1190 }
1191 }
1192
1193 ResetVehicleColourMap();
1195
1196 /* All graph related to companies use the company colour. */
1197 InvalidateWindowData(WindowClass::IncomeGraph, 0);
1198 InvalidateWindowData(WindowClass::OperatingProfitGraph, 0);
1199 InvalidateWindowData(WindowClass::DeliveredCargoGraph, 0);
1200 InvalidateWindowData(WindowClass::PerformanceGraph, 0);
1201 InvalidateWindowData(WindowClass::CompanyValueGraph, 0);
1202 InvalidateWindowData(WindowClass::LinkGraphLegend, 0);
1203 /* The smallmap owner view also stores the company colours. */
1205 InvalidateWindowData(WindowClass::SmallMap, 0, 1);
1206
1207 /* Company colour data is indirectly cached. */
1208 for (Vehicle *v : Vehicle::Iterate()) {
1209 if (v->owner == _current_company) v->InvalidateNewGRFCache();
1210 }
1211
1213 }
1214 return CommandCost();
1215}
1216
1222static bool IsUniqueCompanyName(const std::string &name)
1223{
1224 for (const Company *c : Company::Iterate()) {
1225 if (!c->name.empty() && c->name == name) return false;
1226 }
1227
1228 return true;
1229}
1230
1237CommandCost CmdRenameCompany(DoCommandFlags flags, const std::string &text)
1238{
1239 bool reset = text.empty();
1240
1241 if (!reset) {
1243 if (!IsUniqueCompanyName(text)) return CommandCost(STR_ERROR_NAME_MUST_BE_UNIQUE);
1244 }
1245
1246 if (flags.Test(DoCommandFlag::Execute)) {
1248 if (reset) {
1249 c->name.clear();
1250 } else {
1251 c->name = text;
1252 }
1253
1254 InvalidateWindowClassesData(WindowClass::Company, WID_C_COMPANY_NAME);
1257
1258 std::string new_name = GetString(STR_COMPANY_NAME, c->index);
1259 AI::BroadcastNewEvent(new ScriptEventCompanyRenamed(c->index, new_name));
1260 Game::NewEvent(new ScriptEventCompanyRenamed(c->index, new_name));
1261 }
1262
1263 return CommandCost();
1264}
1265
1271static bool IsUniquePresidentName(const std::string &name)
1272{
1273 for (const Company *c : Company::Iterate()) {
1274 if (!c->president_name.empty() && c->president_name == name) return false;
1275 }
1276
1277 return true;
1278}
1279
1286CommandCost CmdRenamePresident(DoCommandFlags flags, const std::string &text)
1287{
1288 bool reset = text.empty();
1289
1290 if (!reset) {
1292 if (!IsUniquePresidentName(text)) return CommandCost(STR_ERROR_NAME_MUST_BE_UNIQUE);
1293 }
1294
1295 if (flags.Test(DoCommandFlag::Execute)) {
1297
1298 if (reset) {
1299 c->president_name.clear();
1300 } else {
1301 c->president_name = text;
1302
1303 if (c->name_1 == STR_SV_UNNAMED && c->name.empty()) {
1304 Command<Commands::RenameCompany>::Do(DoCommandFlag::Execute, text + " Transport");
1305 }
1306 }
1307
1311
1312 std::string new_name = GetString(STR_PRESIDENT_NAME, c->index);
1313 AI::BroadcastNewEvent(new ScriptEventPresidentRenamed(c->index, new_name));
1314 Game::NewEvent(new ScriptEventPresidentRenamed(c->index, new_name));
1315 }
1316
1317 return CommandCost();
1318}
1319
1327{
1328 const VehicleDefaultSettings *vds = (c == nullptr) ? &_settings_client.company.vehicle : &c->settings.vehicle;
1329 switch (type) {
1330 default: NOT_REACHED();
1331 case VehicleType::Train: return vds->servint_trains;
1332 case VehicleType::Road: return vds->servint_roadveh;
1333 case VehicleType::Aircraft: return vds->servint_aircraft;
1334 case VehicleType::Ship: return vds->servint_ships;
1335 }
1336}
1337
1344{
1345 uint32_t total = 0;
1346 for (RoadType rt : GetMaskForRoadTramType(rtt)) {
1347 total += this->road[rt];
1348 }
1349 return total;
1350}
1351
1362CommandCost CmdGiveMoney(DoCommandFlags flags, Money money, CompanyID dest_company)
1363{
1364 if (!_settings_game.economy.give_money) return CMD_ERROR;
1365
1367 CommandCost amount(ExpensesType::Other, std::min<Money>(money, 20000000LL));
1368
1369 /* You can only transfer funds that is in excess of your loan */
1370 if (c->money - c->current_loan < amount.GetCost() || amount.GetCost() < 0) return CommandCost(STR_ERROR_INSUFFICIENT_FUNDS);
1371 if (!Company::IsValidID(dest_company)) return CMD_ERROR;
1372
1373 if (flags.Test(DoCommandFlag::Execute)) {
1374 /* Add money to company */
1376
1377 if (_networking) {
1378 std::string dest_company_name = GetString(STR_COMPANY_NAME, dest_company);
1379 std::string from_company_name = GetString(STR_COMPANY_NAME, _current_company);
1380
1381 NetworkTextMessage(NetworkAction::GiveMoney, GetDrawStringCompanyColour(_current_company), false, from_company_name, dest_company_name, amount.GetCost());
1382 }
1383 }
1384
1385 /* Subtract money from local-company */
1386 return amount;
1387}
1388
1399{
1400 for (Company *c : Company::Iterate()) {
1401 if (Company::IsHumanID(c->index)) {
1402 return c->index;
1403 }
1404 }
1405
1407 for (CompanyID c = CompanyID::Begin(); c < MAX_COMPANIES; ++c) {
1408 if (!Company::IsValidID(c)) {
1409 return c;
1410 }
1411 }
1412 }
1413
1414 return CompanyID::Begin();
1415}
1416
1417static std::vector<FaceSpec> _faces;
1418
1423{
1424 _faces.clear();
1425 _faces.assign(std::begin(_original_faces), std::end(_original_faces));
1426}
1427
1433{
1434 return static_cast<uint>(std::size(_faces));
1435}
1436
1442const FaceSpec *GetCompanyManagerFaceSpec(uint style_index)
1443{
1444 if (style_index < GetNumCompanyManagerFaceStyles()) return &_faces[style_index];
1445 return nullptr;
1446}
1447
1453std::optional<uint> FindCompanyManagerFaceLabel(std::string_view label)
1454{
1455 auto it = std::ranges::find(_faces, label, &FaceSpec::label);
1456 if (it == std::end(_faces)) return std::nullopt;
1457
1458 return static_cast<uint>(std::distance(std::begin(_faces), it));
1459}
1460
1466FaceVars GetCompanyManagerFaceVars(uint style)
1467{
1468 const FaceSpec *spec = GetCompanyManagerFaceSpec(style);
1469 if (spec == nullptr) return {};
1470 return spec->GetFaceVars();
1471}
1472
1480{
1481 const FaceSpec *spec = GetCompanyManagerFaceSpec(style);
1482 assert(spec != nullptr);
1483
1484 cmf.style = style;
1485 cmf.style_label = spec->label;
1486}
1487
1499
1507uint32_t MaskCompanyManagerFaceBits(const CompanyManagerFace &cmf, FaceVars vars)
1508{
1509 CompanyManagerFace face{};
1510
1511 for (auto var : SetBitIterator(GetActiveFaceVars(cmf, vars))) {
1512 vars[var].SetBits(face, vars[var].GetBits(cmf));
1513 }
1514
1515 return face.bits;
1516}
1517
1524{
1525 uint32_t masked_face_bits = MaskCompanyManagerFaceBits(cmf, GetCompanyManagerFaceVars(cmf.style));
1526 return fmt::format("{}:{}", cmf.style_label, masked_face_bits);
1527}
1528
1534std::optional<CompanyManagerFace> ParseCompanyManagerFaceCode(std::string_view str)
1535{
1536 if (str.empty()) return std::nullopt;
1537
1539 StringConsumer consumer{str};
1540 if (consumer.FindChar(':') != StringConsumer::npos) {
1541 auto label = consumer.ReadUntilChar(':', StringConsumer::SKIP_ONE_SEPARATOR);
1542
1543 /* Read numeric part and ensure it's valid. */
1544 auto bits = consumer.TryReadIntegerBase<uint32_t>(10, true);
1545 if (!bits.has_value() || consumer.AnyBytesLeft()) return std::nullopt;
1546
1547 /* Ensure style label is valid. */
1548 auto style = FindCompanyManagerFaceLabel(label);
1549 if (!style.has_value()) return std::nullopt;
1550
1551 SetCompanyManagerFaceStyle(cmf, *style);
1552 cmf.bits = *bits;
1553 } else {
1554 /* No ':' included, treat as numeric-only. This allows old-style codes to be entered. */
1555 auto bits = ParseInteger(str, 10, true);
1556 if (!bits.has_value()) return std::nullopt;
1557
1558 /* Old codes use bits 0..1 to represent face style. These map directly to the default face styles. */
1559 SetCompanyManagerFaceStyle(cmf, GB(*bits, 0, 2));
1560 cmf.bits = *bits;
1561 }
1562
1563 /* Force the face bits to be valid. */
1564 FaceVars vars = GetCompanyManagerFaceVars(cmf.style);
1566 cmf.bits = MaskCompanyManagerFaceBits(cmf, vars);
1567
1568 return cmf;
1569}
Base functions for all AIs.
AIConfig stores the configuration settings of every AI.
The AIInstance tracks an AI.
static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
static void BroadcastNewEvent(ScriptEvent *event, CompanyID skip_company=CompanyID::Invalid())
Broadcast a new event to all active AIs.
Definition ai_core.cpp:250
static bool CanStartNew()
Is it possible to start a new AI company?
Definition ai_core.cpp:30
static void StartNew(CompanyID company)
Start a new AI company.
Definition ai_core.cpp:36
static void Stop(CompanyID company)
Stop a company to be controlled by an AI.
Definition ai_core.cpp:113
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
Definition ai_core.cpp:231
constexpr bool All(const Timpl &other) const
Test if all of the values are set.
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
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.
ExpensesType GetExpensesType() const
The expense type of the cost.
void MakeError(StringID message)
Makes this CommandCost behave like an error command.
Money GetCost() const
The costs as made up to this moment.
void SetEncodedMessage(EncodedString &&message)
Set the encoded message string.
void SetErrorOwner(Owner owner)
Set the 'owner' (the originator) of this error message.
Container for an encoded string, created by GetEncodedString.
Enum-as-bit-set wrapper.
Iterate a range of enum values.
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
bool Add(std::string_view key)
Add the given key to the authorized keys, when it is not already contained.
Definition network.cpp:186
bool Remove(std::string_view key)
Remove the given key from the authorized keys, when it is exists.
Definition network.cpp:202
Parse data from a string / buffer.
std::optional< T > TryReadIntegerBase(int base, bool clamp=false)
Try to read and parse an integer in number 'base', and then advance the reader.
std::string_view ReadUntilChar(char c, SeparatorUsage sep)
Read data until the first occurrence of 8-bit char 'c', and advance reader.
size_type FindChar(char c) const
Find first occurrence of 8-bit char 'c'.
@ SKIP_ONE_SEPARATOR
Read and discard one separator, do not include it in the result.
bool AnyBytesLeft() const noexcept
Check whether any bytes left to read.
static constexpr size_type npos
Special value for "end of data".
static constexpr TimerGameTick::Ticks DAY_TICKS
1 day is 74 ticks; TimerGameCalendar::date_fract used to be uint16_t and incremented by 885.
static constexpr TimerGameTick::Ticks TICKS_PER_SECOND
Estimation of how many ticks fit in a single second.
A timeout timer will fire once after the interval.
Definition timer.h:116
static Year year
Current year, starting at 0.
static Year year
Current year, starting at 0.
@ CompetitorTimeout
Considering starting a new competitor/AI.
A sort-of mixin that implements 'at(pos)' and 'operator[](pos)' only for a specific type.
Functions related to commands.
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
@ Execute
execute the given command
EnumBitSet< DoCommandFlag, uint16_t > DoCommandFlags
Bitset of DoCommandFlag elements.
Definition of stuff that is very close to a company, like the company struct itself.
uint _cur_company_tick_index
used to generate a name for one company that doesn't have a name yet per tick
void ClearEnginesHiddenFlagOfCompany(CompanyID cid)
Clear the 'hidden' flag for all engines of a new company.
Definition engine.cpp:1044
void UpdateObjectColours(const Company *c)
Updates the colour of the object whenever a company changes.
std::optional< CompanyManagerFace > ParseCompanyManagerFaceCode(std::string_view str)
Parse a face code into a company manager face.
static void GenerateCompanyName(Company *c)
Generate the name of a company from the last build coordinate.
static bool IsValidCompanyManagerFace(CompanyManagerFace cmf)
Checks whether a company manager's face is a valid encoding.
const FaceSpec * GetCompanyManagerFaceSpec(uint style_index)
Get the definition of a company manager face style.
void OnTick_Companies()
Called every tick for updating some company info.
std::array< StringParameter, 2 > GetParamsForOwnedBy(Owner owner, TileIndex tile)
Get the right StringParameters for STR_ERROR_OWNED_BY.
FaceVars GetCompanyManagerFaceVars(uint style)
Get the face variables for a face style.
CommandCost CmdCompanyAllowListCtrl(DoCommandFlags flags, CompanyAllowListCtrlAction action, const std::string &public_key)
Add or remove the given public key to the allow list of this company.
void RandomiseCompanyManagerFace(CompanyManagerFace &cmf, Randomizer &randomizer)
Completely randomise a company manager face, including style.
void ResetFaces()
Reset company manager face styles to default.
Company * DoStartupNewCompany(bool is_ai, CompanyID company=CompanyID::Invalid())
Create a new company and sets all company variables default values.
void DrawCompanyIcon(CompanyID c, int x, int y)
Draw the icon of a company.
uint32_t MaskCompanyManagerFaceBits(const CompanyManagerFace &cmf, FaceVars vars)
Mask company manager face bits to ensure they are all within range.
static const std::initializer_list< Colours > _similar_colour[to_underlying(Colours::End)]
Similar colours, so we can try to prevent same coloured companies.
TimeoutTimer< TimerGameTick > _new_competitor_timeout({ TimerGameTick::Priority::CompetitorTimeout, 0 }, []() { if(_game_mode==GameMode::Menu||!AI::CanStartNew()) return;if(_networking &&Company::GetNumItems() >=_settings_client.network.max_companies) return;if(_settings_game.difficulty.competitors_interval==0) return;uint8_t n=0;for(const Company *c :Company::Iterate()) { if(c->is_ai) n++;} if(n >=_settings_game.difficulty.max_no_competitors) return;Command< Commands::CompanyControl >::Post(CompanyCtrlAction::NewAI, CompanyID::Invalid(), CompanyRemoveReason::None, ClientID::Invalid);})
Start a new competitor company if possible.
std::string _company_manager_face
for company manager face storage in openttd.cfg
static Colours GenerateCompanyColour()
Generate a company colour.
static void GeneratePresidentName(Company *c)
Generate a random president name of a company.
TypedIndexContainer< std::array< Colours, MAX_COMPANIES >, CompanyID > _company_colours
NOSAVE: can be determined from company structs.
void ResetCompanyLivery(Company *c)
Reset the livery schemes to the company's primary colour.
void UpdateCompanyLiveries(Company *c)
Update liveries for a company.
CommandCost CheckTileOwnership(TileIndex tile)
Check whether the current owner owns the stuff on the given tile.
CommandCost CmdSetCompanyColour(DoCommandFlags flags, LiveryScheme scheme, bool primary, Colours colour)
Change the company's company-colour.
CommandCost CmdCompanyCtrl(DoCommandFlags flags, CompanyCtrlAction cca, CompanyID company_id, CompanyRemoveReason reason, ClientID client_id)
Control the companies: add, delete, etc.
static std::vector< FaceSpec > _faces
All company manager face styles.
void InvalidateCompanyWindows(const Company *company)
Mark all finance windows owned by a company as needing a refresh.
int CompanyServiceInterval(const Company *c, VehicleType type)
Get the service interval for the given company and vehicle type.
PaletteID GetCompanyPalette(CompanyID company)
Get the palette for recolouring with a company colour.
void SetCompanyManagerFaceStyle(CompanyManagerFace &cmf, uint style)
Set a company face style.
bool CheckCompanyHasMoney(CommandCost &cost)
Verify whether the company can pay the bill.
static void SubtractMoneyFromCompany(Company *c, const CommandCost &cost)
Deduct costs of a command from the money of a company.
static const IntervalTimer< TimerWindow > invalidate_company_windows_interval(std::chrono::milliseconds(1), [](auto) { for(CompanyID cid :_dirty_company_finances) { if(cid==_local_company) SetWindowWidgetDirty(WindowClass::Statusbar, 0, WID_S_RIGHT);Window *w=FindWindowById(WindowClass::Finances, cid);if(w !=nullptr) { w->SetWidgetDirty(WID_CF_EXPS_PRICE3);w->SetWidgetDirty(WID_CF_OWN_VALUE);w->SetWidgetDirty(WID_CF_LOAN_VALUE);w->SetWidgetDirty(WID_CF_BALANCE_VALUE);w->SetWidgetDirty(WID_CF_MAXLOAN_VALUE);} SetWindowWidgetDirty(WindowClass::Company, cid, WID_C_DESC_COMPANY_VALUE);} _dirty_company_finances.Reset();})
Refresh all company finance windows previously marked dirty.
CompanyID GetFirstPlayableCompanyID()
Get the index of the first available company.
static CompanyMask _dirty_company_finances
Bitmask of company finances that should be marked dirty.
CommandCost CmdSetCompanyManagerFace(DoCommandFlags flags, uint style, uint32_t bits)
Change the company manager's face.
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...
Money GetAvailableMoneyForCommand()
This functions returns the money which can be used to execute a command.
void CompanyAdminUpdate(const Company *company)
Called whenever company related information changes in order to notify admins.
std::optional< uint > FindCompanyManagerFaceLabel(std::string_view label)
Find a company manager face style by label.
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
void CompanyAdminRemove(CompanyID company_id, CompanyRemoveReason reason)
Called whenever a company is removed in order to notify admins.
static const EnumIndexArray< uint8_t, Colours, Colours::End > _colour_sort
Sorting weights for the company colours.
CommandCost CmdRenamePresident(DoCommandFlags flags, const std::string &text)
Change the name of the president.
static bool SetCompanyName(std::span< const std::string > other_names, Company *c, const Town *t, StringID str, uint32_t strp)
Set a company name based on type and seed, if the name is unique and shorter than the max length.
CompanyPool _company_pool("Company")
Pool of companies.
uint GetNumCompanyManagerFaceStyles()
Get the number of company manager face styles.
std::string FormatCompanyManagerFaceCode(const CompanyManagerFace &cmf)
Get a face code representation of a company manager face.
Money GetAvailableMoney(CompanyID company)
Get the amount of money that a company has available, or INT64_MAX if there is no such valid company.
void UpdateLandscapingLimits()
Update the landscaping limits per company.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
void InitializeCompanies()
Initialize the pool of companies.
void StartupCompanies()
Start of a new game.
bool CheckTakeoverVehicleLimit(CompanyID cbig, CompanyID csmall)
Can company cbig buy company csmall without exceeding vehicle limits?
static bool IsUniqueCompanyName(const std::string &name)
Is the given name in use as name of a company?
static bool IsUniquePresidentName(const std::string &name)
Is the given name in use as president name of a company?
CompanyID _current_company
Company currently doing an action.
CommandCost CmdGiveMoney(DoCommandFlags flags, Money money, CompanyID dest_company)
Transfer funds (money) from one company to another.
static const IntervalTimer< TimerGameEconomy > _economy_companies_yearly({TimerGameEconomy::Trigger::Year, TimerGameEconomy::Priority::Company}, [](auto) { for(Company *c :Company::Iterate()) { std::rotate(std::rbegin(c->yearly_expenses), std::rbegin(c->yearly_expenses)+1, std::rend(c->yearly_expenses));c->yearly_expenses[0].fill(0);InvalidateWindowData(WindowClass::Finances, c->index);} if(_settings_client.gui.show_finances &&_local_company !=COMPANY_SPECTATOR) { ShowCompanyFinances(_local_company);Company *c=Company::Get(_local_company);if(c->num_valid_stat_ent > 5 &&c->old_economy[0].performance_history< c->old_economy[4].performance_history) { if(_settings_client.sound.new_year) SndPlayFx(SND_01_BAD_YEAR);} else { if(_settings_client.sound.new_year) SndPlayFx(SND_00_GOOD_YEAR);} } })
A year has passed, update the economic data of all companies, and perhaps show the financial overview...
static void HandleBankruptcyTakeover(Company *c)
Handle the bankruptcy take over of a company.
ExtendedTextColour GetDrawStringCompanyColour(CompanyID company)
Get the colour for DrawString-subroutines which matches the colour of the company.
CommandCost CmdRenameCompany(DoCommandFlags flags, const std::string &text)
Change the name of the company.
void SubtractMoneyFromCompanyFract(CompanyID company, const CommandCost &cst)
Subtract money from a company, including the money fraction.
static bool SetPresidentName(std::span< const std::string > other_names, Company *c, uint32_t seed)
Set a company's president name based on seed, if the name is unique and shorter than the max length.
Command definitions related to companies.
This file contains all definitions for default company faces.
static FaceSpec _original_faces[]
Original face styles.
Functions related to companies.
bool IsInteractiveCompany(CompanyID company)
Is the user representing company?
void ChangeOwnershipOfCompanyItems(Owner old_owner, Owner new_owner)
Change the ownership of all the items of a company.
Definition economy.cpp:325
void ShowBuyCompanyDialog(CompanyID company, bool hostile_takeover)
Show the query to buy another company.
bool IsLocalCompany()
Is the current company the local company?
void ShowCompanyFinances(CompanyID company)
Open the finances window of a company.
GUI Functions related to companies.
void CloseCompanyWindows(CompanyID company)
Close all windows of a company.
Definition window.cpp:1271
Functionality related to the company manager's face.
void RandomiseCompanyManagerFaceBits(CompanyManagerFace &cmf, FaceVars vars, Randomizer &randomizer)
Make a random new face without changing the face style.
uint64_t GetActiveFaceVars(const CompanyManagerFace &cmf, FaceVars vars)
Get a bitmask of currently active face variables.
void ScaleAllCompanyManagerFaceBits(CompanyManagerFace &cmf, FaceVars vars)
Scales all company manager's face bits to the correct scope.
static const uint MAX_LENGTH_PRESIDENT_NAME_CHARS
The maximum length of a president name in characters including '\0'.
static const uint MAX_LENGTH_COMPANY_NAME_CHARS
The maximum length of a company name in characters including '\0'.
CompanyCtrlAction
The action to do with Commands::CompanyControl.
@ New
Create a new company.
@ NewAI
Create a new AI company.
@ Delete
Delete a company.
static constexpr CompanyID COMPANY_SPECTATOR
The client is spectating.
static constexpr Owner OWNER_END
Last + 1 owner.
CompanyAllowListCtrlAction
The action to do with Commands::CompanyAllowListControl.
@ RemoveKey
Remove a public key.
@ AddKey
Create a public key.
@ AllowListed
Allow only listed keys to join the company.
@ AllowAny
Allow joining the company without a key.
static constexpr Owner OWNER_TOWN
A town owns the tile, or a town is expanding.
static constexpr Owner OWNER_NONE
The tile has no ownership.
static constexpr Owner INVALID_OWNER
An invalid owner.
CompanyRemoveReason
The reason why the company was removed.
@ None
Dummy reason for actions that don't need one.
@ End
Sentinel for end.
Types related to the company widgets.
@ WID_CF_OWN_VALUE
Own funds, not including loan.
@ WID_CF_LOAN_VALUE
Loan.
@ WID_CF_BALANCE_VALUE
Bank balance value.
@ WID_CF_EXPS_PRICE3
Column for year Y expenses.
@ WID_CF_MAXLOAN_VALUE
Max loan widget.
@ WID_C_DESC_COMPANY_VALUE
Company value.
@ WID_C_PRESIDENT_NAME
Button to change president name.
@ WID_C_COMPANY_NAME
Button to change company name.
static const uint NETWORK_PUBLIC_KEY_LENGTH
The maximum length of the hexadecimal encoded public keys, in bytes including '\0'.
Definition config.h:99
@ LoanInterest
Interest payments over the loan.
@ TrainRun
Running costs trains.
@ AircraftRevenue
Revenue from aircraft.
@ Invalid
Invalid expense type.
@ Property
Property costs.
@ Other
Other expenses.
@ RoadVehRevenue
Revenue from road vehicles.
@ AircraftRun
Running costs aircraft.
@ RoadVehRun
Running costs road vehicles.
@ ShipRevenue
Revenue from ships.
@ TrainRevenue
Revenue from trains.
@ ShipRun
Running costs ships.
static const int LOAN_INTERVAL
The "steps" in loan size, in British Pounds!
static const int64_t INITIAL_LOAN
The size of loan for a new company, in British Pounds!
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23).
Definition enum_type.hpp:21
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.
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition gfx.cpp:1032
uint32_t PaletteID
The number of the palette.
Definition gfx_type.h:18
Colours
One of 16 base colours used for companies and windows/widgets.
Definition gfx_type.h:283
@ Begin
Begin marker.
Definition gfx_type.h:284
@ White
White.
Definition gfx_type.h:300
@ PaleGreen
Pale green.
Definition gfx_type.h:286
@ Mauve
Mauve.
Definition gfx_type.h:295
@ Invalid
Invalid marker.
Definition gfx_type.h:302
@ LightBlue
Light blue.
Definition gfx_type.h:290
@ Yellow
Yellow.
Definition gfx_type.h:288
@ End
End-of-array marker.
Definition gfx_type.h:301
@ DarkBlue
Dark blue.
Definition gfx_type.h:285
@ Orange
Orange.
Definition gfx_type.h:297
@ Blue
Blue.
Definition gfx_type.h:293
@ Purple
Purple.
Definition gfx_type.h:296
@ Grey
Grey.
Definition gfx_type.h:299
@ Green
Green.
Definition gfx_type.h:291
@ Cream
Cream.
Definition gfx_type.h:294
@ Brown
Brown.
Definition gfx_type.h:298
@ DarkGreen
Dark green.
Definition gfx_type.h:292
Goal base class.
void UpdateCompanyGroupLiveries(const Company *c)
Update group liveries for a company.
void MarkWholeScreenDirty()
This function mark the whole screen as dirty.
Definition gfx.cpp:1548
LiveryScheme
List of different livery schemes.
Definition livery.h:22
@ Steam
Steam engines.
Definition livery.h:27
@ Default
Default scheme.
Definition livery.h:24
@ End
End marker.
Definition livery.h:58
constexpr bool IsInsideMM(const size_t x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
bool _networking
are we in networking mode?
Definition network.cpp:63
bool _network_server
network-server is active
Definition network.cpp:64
ClientID _network_own_client_id
Our client identifier.
Definition network.cpp:68
void NetworkTextMessage(NetworkAction action, ExtendedTextColour colour, bool self_send, std::string_view name, std::string_view str, StringParameter &&data)
Writes a text-message to the console and the chat box.
Definition network.cpp:240
Basic functions/variables used all over the place.
void NetworkAdminCompanyUpdate(const Company *company)
Notify the admin network of company updates.
void NetworkAdminCompanyNew(const Company *company)
Notify the admin network of a new company.
void NetworkAdminCompanyRemove(CompanyID company_id, AdminCompanyRemoveReason bcrr)
Notify the admin network of a company to be removed (including the reason why).
Server part of the admin network protocol.
Base core network types and some helper functions to access them.
Network functions used by other parts of OpenTTD.
void NetworkServerNewCompany(const Company *company, NetworkClientInfo *ci)
Perform all the server specific administration of a new company.
void NetworkUpdateClientInfo(ClientID client_id)
Send updated client info of a particular client.
@ GiveMoney
A company was given money.
@ Team
Send message/notice to everyone playing the same company (Team).
ClientID
'Unique' identifier to be given to clients
@ Invalid
Client is not part of anything.
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
@ CompanyInfo
Company info (new companies, bankruptcy messages).
Definition news_type.h:35
@ Company
Company news item. (Newspaper with face).
Definition news_type.h:85
@ Editor
In the scenario editor.
Definition openttd.h:21
@ Menu
In the main menu.
Definition openttd.h:19
PixelColour GetColourGradient(Colours colour, Shade shade)
Get colour gradient palette index.
Definition palette.cpp:393
@ Normal
Normal colour shade.
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.
RailTypes GetCompanyRailTypes(CompanyID company, bool introduces)
Get the rail types the given company can build.
Definition rail.cpp:137
Rail specific functions.
void SetDefaultRailGui()
Set the initial (default) railtype to use.
Randomizer _random
Random used in the game state calculations.
RoadTypes GetCompanyRoadTypes(CompanyID company, bool introduces)
Get the road types the given company can build.
Definition road.cpp:209
RoadTypes GetMaskForRoadTramType(RoadTramType rtt)
Get the mask for road types of the given RoadTramType.
Definition road.h:185
void SetDefaultRoadGui()
Set the initial (default) road & tram type to use.
Functions/types related to the road GUIs.
RoadType
The different roadtypes we support.
Definition road_type.h:24
RoadTramType
The different types of road type.
Definition road_type.h:38
A number of safeguards to prevent using unsafe methods.
void SyncCompanySettings()
Sync all company settings in a multiplayer game.
void SetDefaultCompanySettings(CompanyID cid)
Set the company settings for a new company to their default values.
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
Functions related to setting/changing the settings.
void BuildOwnerLegend()
Completes the array for the owned property legend.
Smallmap GUI functions.
Functions related to sound.
@ SND_01_BAD_YEAR
40 == 0x28 New year: performance declined
Definition sound_type.h:87
@ SND_00_GOOD_YEAR
39 == 0x27 New year: performance improved
Definition sound_type.h:86
static PaletteID GetColourPalette(Colours colour)
Get recolour palette for a colour.
Definition sprite.h:221
static const SpriteID SPR_COMPANY_ICON
Icon showing company colour.
Definition sprites.h:386
Types related to the statusbar widgets.
@ WID_S_RIGHT
Right part; bank balance.
Definition of base types and functions in a cross-platform compatible way.
StoryPage base class.
size_t Utf8StringLength(std::string_view str)
Get the length of an UTF-8 encoded string in number of characters and thus not the number of bytes th...
Definition string.cpp:350
Parse strings.
static std::optional< T > ParseInteger(std::string_view arg, int base=10, bool clamp=false)
Change a string into its number representation.
EncodedString GetEncodedStringWithArgs(StringID str, std::span< const StringParameter > params)
Encode a string with its parameters into an encoded string.
Definition strings.cpp:101
EncodedString GetEncodedString(StringID str)
Encode a string with no parameters into an encoded string.
Definition strings.cpp:89
std::string GetString(StringID string)
Resolve the given StringID into a std::string with formatting but no parameters.
Definition strings.cpp:423
Functions related to OTTD's strings.
static constexpr StringID SPECSTR_COMPANY_NAME_START
Special strings for company names on the form "TownName transport".
static constexpr uint16_t SPECSTR_TOWNNAME_START
Special strings for town names.
static constexpr StringID SPECSTR_ANDCO_NAME
Special string for Surname & Co company names.
static constexpr StringID SPECSTR_PRESIDENT_NAME
Special string for the president's name.
StrongType::Typedef< uint32_t, struct StringIDTag, StrongType::Compare, StrongType::Integer > StringID
Numeric value that represents a string, independent of the selected language.
Money income
The amount of income.
Money expenses
The amount of expenses.
uint32_t GetRoadTramTotal(RoadTramType rtt) const
Get total sum of all owned road bits.
std::array< uint32_t, ROADTYPE_END > road
Count of company owned track bits for each road type.
uint32_t bits
Company manager face bits, meaning is dependent on style.
uint style
Company manager face style.
std::string style_label
Face style label.
CompanyManagerFace face
The face of the president.
Definition news_type.h:165
Colours colour
The colour related to the company.
Definition news_type.h:166
CompanyNewsInformation(StringID title, const struct Company *c, const struct Company *other=nullptr)
Fill the CompanyNewsInformation struct with the required data.
std::string president_name
The name of the president.
Definition news_type.h:161
std::string company_name
The name of the company.
Definition news_type.h:160
std::string other_company_name
The name of the company taking over this one.
Definition news_type.h:162
uint32_t clear_limit
Amount of tiles we can (still) clear (times 65536).
CompanyMask bankrupt_asked
which companies were asked about buying it?
std::string president_name
Name of the president if the user changed 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
NetworkAuthorizedKeys allow_list
Public keys of clients that are allowed to join this company.
bool allow_any
Set if anyone is allowed to join this company.
uint32_t build_object_limit
Amount of tiles we can (still) build objects on (times 65536). Also applies to buying land and placin...
uint32_t name_2
Parameter of name_1.
uint8_t money_fraction
Fraction of money of the company, too small to represent in money.
bool is_ai
If true, the company is (also) controlled by the computer (a NoAI program).
uint32_t president_name_2
Parameter of president_name_1.
StringID name_1
Name of the company if the user did not change it.
Money current_loan
Amount of money borrowed from the bank.
TimerGameCalendar::Year inaugurated_year_calendar
Calendar year of starting the company. Used to display proper Inauguration year while in wallclock mo...
uint32_t terraform_limit
Amount of tileheights we can (still) terraform (times 65536).
TimerGameEconomy::Year inaugurated_year
Economy year of starting the company.
CompanyEconomyEntry cur_economy
Economic data of the company of this quarter.
Colours colour
Company colour.
uint32_t tree_limit
Amount of trees we can (still) plant (times 65536).
std::array< CompanyEconomyEntry, MAX_HISTORY_QUARTERS > old_economy
Economic data of the company of the last MAX_HISTORY_QUARTERS quarters.
CompanyManagerFace face
Face description of the president.
Money max_loan
Max allowed amount of the loan or COMPANY_MAX_LOAN_DEFAULT.
std::array< Expenses, 3 > yearly_expenses
Expenses of the company for the last three years.
TileIndex last_build_coordinate
Coordinate of the last build thing by this company.
StringID president_name_1
Name of the president if the user did not change it.
std::string name
Name of the company if the user changed it.
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.
VehicleTypeIndexArray< GroupStatistics > group_all
NOSAVE: Statistics for the ALL_GROUP group.
static bool IsHumanID(auto index)
Is this company a company not controlled by a NoAI program?
RoadTypes avail_roadtypes
Road types available to this company.
~Company()
Close the associated company windows.
RailTypes avail_railtypes
Rail types available to this company.
static void PostDestructor(size_t index)
Invalidating some stuff after removing item from the pool.
Company(CompanyID index, StringID name_1={}, bool is_ai=false)
Constructor.
Container for the text colour and some text colour related flags for drawing.
Definition gfx_type.h:349
Group data.
Definition group.h:76
@ Primary
Primary colour is set.
Definition livery.h:85
@ Secondary
Secondary colour is set.
Definition livery.h:86
Container for all information known about a client.
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it's client-identifier.
Definition network.cpp:114
CompanyID client_playas
As which company is this client playing (CompanyID).
ClientID client_id
Client identifier (same as ClientState->client_id).
static Pool::IterateWrapper< Company > Iterate(size_t from=0)
static T * Create(Targs &&... args)
static T * CreateAtIndex(CompanyID index, Targs &&... args)
static Company * Get(auto index)
static bool CanAllocateItem(size_t n=1)
static Company * GetIfValid(auto index)
Structure to encapsulate the pseudo random number generators.
uint32_t Next()
Generate the next pseudo random number.
Iterable ensemble of each set bit in a value.
Town data structure.
Definition town.h:64
std::string name
Custom town name. If empty, the town was not renamed and uses the generated name.
Definition town.h:74
uint32_t townnameparts
Random number that give unique town name when passed to generator.
Definition town.h:73
uint16_t townnametype
The style of the name.
Definition town.h:72
Default settings for vehicles.
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
uint16_t servint_trains
service interval for trains
Vehicle data structure.
Data structure for an opened window.
Definition window_gui.h:272
void SetWidgetDirty(WidgetID widget_index) const
Invalidate a widget, i.e.
Definition window.cpp:565
AdminCompanyRemoveReason
Reasons for removing a company - communicated to admins.
Definition tcp_admin.h:106
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition tile_map.h:178
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
Definition of Interval and OneShot timers.
Definition of the game-economy-timer.
Definition of the tick-based game-timer.
Definition of the Window system.
Base of the town class.
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
Base class for all vehicles.
Functions related to vehicles.
VehicleType
Available vehicle types.
@ Ship
Ship vehicle type.
@ Aircraft
Aircraft vehicle type.
@ Road
Road vehicle type.
@ Train
Train vehicle type.
void CloseConstructionWindows()
Close all windows that are used for construction of vehicle etc.
Definition window.cpp:3464
void CloseWindowById(WindowClass cls, WindowNumber number, bool force, int data)
Close a window by its class and window number (if it is open).
Definition window.cpp:1242
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
Window * FindWindowById(WindowClass cls, WindowNumber number)
Find a window by its class and window number.
Definition window.cpp:1199
void SetWindowWidgetDirty(WindowClass cls, WindowNumber number, WidgetID widget_index)
Mark a particular widget in a particular window as dirty (in need of repainting).
Definition window.cpp:3271
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
Window functions not directly related to making/drawing windows.
@ Join
Network join status.
Definition window_type.h:56