CMD_BUY_SHARE_IN_COMPANY,         ///< buy a share from a company

	CMD_SELL_SHARE_IN_COMPANY,        ///< sell a share from a company

	CMDT_MONEY_MANAGEMENT,       ///< Management of money, i.e. loans and shares.

	std::array<Owner, MAX_COMPANY_SHARE_OWNERS> share_owners; ///< Owners of the shares of the company. #INVALID_OWNER if nobody has bought them yet.

		  location_of_HQ(0), last_build_coordinate(0), share_owners(), inaugurated_year(0),

Money CalculateCompanyValueExcludingShares(const Company *c, bool including_loan = true);

	std::fill(this->share_owners.begin(), this->share_owners.end(), INVALID_OWNER);

	std::fill(c->share_owners.begin(), c->share_owners.end(), INVALID_OWNER);

					NWidget(NWID_SELECTION, INVALID_COLOUR, WID_C_SELECT_DESC_OWNERS),

						NWidget(NWID_VERTICAL), SetPIP(5, 5, 4),

							NWidget(WWT_EMPTY, INVALID_COLOUR, WID_C_DESC_OWNERS), SetMinimalTextLines(MAX_COMPANY_SHARE_OWNERS, 0),

							NWidget(NWID_SPACER), SetFill(0, 1),

						EndContainer(),

					EndContainer(),

		NWidget(NWID_HORIZONTAL, NC_EQUALSIZE),

			NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_C_BUY_SHARE), SetFill(1, 0), SetDataTip(STR_COMPANY_VIEW_BUY_SHARE_BUTTON, STR_COMPANY_VIEW_BUY_SHARE_TOOLTIP),

			NWidget(WWT_PUSHTXTBTN, COLOUR_GREY, WID_C_SELL_SHARE), SetFill(1, 0), SetDataTip(STR_COMPANY_VIEW_SELL_SHARE_BUTTON, STR_COMPANY_VIEW_SELL_SHARE_TOOLTIP),

		EndContainer(),

int GetAmountOwnedBy(const Company *c, Owner owner)

{

	auto share_owned_by = [owner](auto share_owner) { return share_owner == owner; };

	return std::count_if(c->share_owners.begin(), c->share_owners.end(), share_owned_by);

}

		/* Display planes of the #WID_C_SELECT_BUTTONS selection widget. */

		CWP_BUTTONS_LOCAL = 0, ///< Buttons of the local company.

		CWP_BUTTONS_OTHER,     ///< Buttons of the other companies.

			int plane = local ? CWP_BUTTONS_LOCAL : CWP_BUTTONS_OTHER;

			/* Owners of company */

			auto invalid_owner = [](auto owner) { return owner == INVALID_COMPANY; };

			plane = std::all_of(c->share_owners.begin(), c->share_owners.end(), invalid_owner) ? SZSP_HORIZONTAL : 0;

			wi = this->GetWidget<NWidgetStacked>(WID_C_SELECT_DESC_OWNERS);

			if (plane != wi->shown_plane) {

				wi->SetDisplayedPlane(plane);

				reinit = true;

			}

			case WID_C_DESC_OWNERS: {

				for (const Company *c2 : Company::Iterate()) {

					SetDParamMaxValue(0, 75);

					SetDParam(1, c2->index);

					size->width = std::max(size->width, GetStringBoundingBox(STR_COMPANY_VIEW_SHARES_OWNED_BY).width);

				}

				break;

			}

			case WID_C_DESC_OWNERS: {

				uint y = r.top;

				for (const Company *c2 : Company::Iterate()) {

					uint amt = GetAmountOwnedBy(c, c2->index);

					if (amt != 0) {

						SetDParam(0, amt * 25);

						SetDParam(1, c2->index);

						DrawString(r.left, r.right, y, STR_COMPANY_VIEW_SHARES_OWNED_BY);

						y += FONT_HEIGHT_NORMAL;

					}

				}

				break;

			}

			case WID_C_BUY_SHARE:

				Command<CMD_BUY_SHARE_IN_COMPANY>::Post(STR_ERROR_CAN_T_BUY_25_SHARE_IN_THIS, (CompanyID)this->window_number);

				break;

			case WID_C_SELL_SHARE:

				Command<CMD_SELL_SHARE_IN_COMPANY>::Post(STR_ERROR_CAN_T_SELL_25_SHARE_IN, (CompanyID)this->window_number);

				break;

	/**

	 * Some data on this window has become invalid.

	 * @param data Information about the changed data.

	 * @param gui_scope Whether the call is done from GUI scope. You may not do everything when not in GUI scope. See #InvalidateWindowData() for details.

	 */

	void OnInvalidateData(int data = 0, bool gui_scope = true) override

	{

		if (this->window_number == _local_company) return;

		if (_settings_game.economy.allow_shares) { // Shares are allowed

			const Company *c = Company::Get(this->window_number);

			/* If all shares are owned by someone (none by nobody), disable buy button */

			this->SetWidgetDisabledState(WID_C_BUY_SHARE, GetAmountOwnedBy(c, INVALID_OWNER) == 0 ||

					/* Only 25% left to buy. If the company is human, disable buying it up.. TODO issues! */

					(GetAmountOwnedBy(c, INVALID_OWNER) == 1 && !c->is_ai) ||

					/* Spectators cannot do anything of course */

					_local_company == COMPANY_SPECTATOR);

			/* If the company doesn't own any shares, disable sell button */

			this->SetWidgetDisabledState(WID_C_SELL_SHARE, (GetAmountOwnedBy(c, _local_company) == 0) ||

					/* Spectators cannot do anything of course */

					_local_company == COMPANY_SPECTATOR);

		} else { // Shares are not allowed, disable buy/sell buttons

			this->DisableWidget(WID_C_BUY_SHARE);

			this->DisableWidget(WID_C_SELL_SHARE);

		}

	}

static const uint MAX_COMPANY_SHARE_OWNERS        =  4; ///< The maximum number of shares of a company that can be owned by another company.

extern int GetAmountOwnedBy(const Company *c, Owner owner);

 * assets (vehicles, stations, shares) and money minus the loan,

	Money owned_shares_value = 0;

	for (const Company *co : Company::Iterate()) {

		int shares_owned = GetAmountOwnedBy(co, c->index);

		if (shares_owned > 0) owned_shares_value += (CalculateCompanyValueExcludingShares(co) / 4) * shares_owned;

	}

	return owned_shares_value + CalculateCompanyValueExcludingShares(c);

}

Money CalculateCompanyValueExcludingShares(const Company *c, bool including_loan)

{

	/* See if the old_owner had shares in other companies */

	for (const Company *c : Company::Iterate()) {

		for (auto share_owner : c->share_owners) {

			if (share_owner == old_owner) {

				/* Sell its shares */

				CommandCost res = Command<CMD_SELL_SHARE_IN_COMPANY>::Do(DC_EXEC | DC_BANKRUPT, c->index);

				/* Because we are in a DoCommand, we can't just execute another one and

				 *  expect the money to be removed. We need to do it ourself! */

				SubtractMoneyFromCompany(res);

			}

		}

	}

	/* Sell all the shares that people have on this company */

	Backup<CompanyID> cur_company2(_current_company, FILE_LINE);

	Company *c = Company::Get(old_owner);

	for (auto &share_owner : c->share_owners) {

		if (share_owner == INVALID_OWNER) continue;

		if (c->bankrupt_value == 0 && share_owner == new_owner) {

			/* You are the one buying the company; so don't sell the shares back to you. */

			share_owner = INVALID_OWNER;

		} else {

			cur_company2.Change(share_owner);

			/* Sell the shares */

			CommandCost res = Command<CMD_SELL_SHARE_IN_COMPANY>::Do(DC_EXEC | DC_BANKRUPT, old_owner);

			/* Because we are in a DoCommand, we can't just execute another one and

			 *  expect the money to be removed. We need to do it ourself! */

			SubtractMoneyFromCompany(res);

		}

	}

	cur_company2.Restore();

 * Acquire shares in an opposing company.

 * @param flags type of operation

 * @param target_company company to buy the shares from

 * @return the cost of this operation or an error

 */

CommandCost CmdBuyShareInCompany(DoCommandFlag flags, CompanyID target_company)

{

	CommandCost cost(EXPENSES_OTHER);

	Company *c = Company::GetIfValid(target_company);

	/* Check if buying shares is allowed (protection against modified clients)

	 * Cannot buy own shares */

	if (c == nullptr || !_settings_game.economy.allow_shares || _current_company == target_company) return CMD_ERROR;

	/* Protect new companies from hostile takeovers */

	if (TimerGameCalendar::year - c->inaugurated_year < _settings_game.economy.min_years_for_shares) return_cmd_error(STR_ERROR_PROTECTED);

	/* Those lines are here for network-protection (clients can be slow) */

	if (GetAmountOwnedBy(c, INVALID_OWNER) == 0) return cost;

	if (GetAmountOwnedBy(c, INVALID_OWNER) == 1) {

		if (!c->is_ai) return cost; //  We can not buy out a real company (temporarily). TODO: well, enable it obviously.

		if (GetAmountOwnedBy(c, _current_company) == 3 && !MayCompanyTakeOver(_current_company, target_company)) return_cmd_error(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME);

	}

	cost.AddCost(CalculateCompanyValue(c) >> 2);

	if (flags & DC_EXEC) {

		auto unowned_share = std::find(c->share_owners.begin(), c->share_owners.end(), INVALID_OWNER);

		assert(unowned_share != c->share_owners.end()); // share owners is guaranteed to contain at least one INVALID_OWNER, i.e. unowned share

		*unowned_share = _current_company;

		auto current_company_owns_share = [](auto share_owner) { return share_owner == _current_company; };

		if (std::all_of(c->share_owners.begin(), c->share_owners.end(), current_company_owns_share)) {

			c->bankrupt_value = 0;

			DoAcquireCompany(c);

		}

		InvalidateWindowData(WC_COMPANY, target_company);

		CompanyAdminUpdate(c);

	}

	return cost;

}

/**

 * Sell shares in an opposing company.

 * @param flags type of operation

 * @param target_company company to sell the shares from

 * @return the cost of this operation or an error

 */

CommandCost CmdSellShareInCompany(DoCommandFlag flags, CompanyID target_company)

{

	Company *c = Company::GetIfValid(target_company);

	/* Cannot sell own shares */

	if (c == nullptr || _current_company == target_company) return CMD_ERROR;

	/* Check if selling shares is allowed (protection against modified clients).

	 * However, we must sell shares of companies being closed down. */

	if (!_settings_game.economy.allow_shares && !(flags & DC_BANKRUPT)) return CMD_ERROR;

	/* Those lines are here for network-protection (clients can be slow) */

	if (GetAmountOwnedBy(c, _current_company) == 0) return CommandCost();

	/* adjust it a little to make it less profitable to sell and buy */

	Money cost = CalculateCompanyValue(c) >> 2;

	cost = -(cost - (cost >> 7));

	if (flags & DC_EXEC) {

		auto our_owner = std::find(c->share_owners.begin(), c->share_owners.end(), _current_company);

		assert(our_owner != c->share_owners.end()); // share owners is guaranteed to contain at least one INVALID_OWNER

		*our_owner = INVALID_OWNER;

		InvalidateWindowData(WC_COMPANY, target_company);

		CompanyAdminUpdate(c);

	}

	return CommandCost(EXPENSES_OTHER, cost);

}

/**

CommandCost CmdBuyShareInCompany(DoCommandFlag flags, CompanyID target_company);

CommandCost CmdSellShareInCompany(DoCommandFlag flags, CompanyID target_company);

DEF_CMD_TRAIT(CMD_BUY_SHARE_IN_COMPANY,  CmdBuyShareInCompany,  0, CMDT_MONEY_MANAGEMENT)

DEF_CMD_TRAIT(CMD_SELL_SHARE_IN_COMPANY, CmdSellShareInCompany, 0, CMDT_MONEY_MANAGEMENT)

STR_CONFIG_SETTING_ALLOW_SHARES                                 :Allow buying shares from other companies: {STRING2}

STR_CONFIG_SETTING_ALLOW_SHARES_HELPTEXT                        :When enabled, allow buying and selling of company shares. Shares will only be available for companies reaching a certain age

STR_CONFIG_SETTING_MIN_YEARS_FOR_SHARES                         :Minimum company age to trade shares: {STRING2}

STR_CONFIG_SETTING_MIN_YEARS_FOR_SHARES_HELPTEXT                :Set the minimum age of a company for others to be able to buy and sell shares from them.

STR_CONFIG_SETTING_MIN_YEARS_FOR_SHARES_VALUE                   :{COMMA} year{P "" s}

###setting-zero-is-special

STR_CONFIG_SETTING_MIN_YEARS_FOR_SHARES_NO_MIN                  :No minimum

STR_COMPANY_VIEW_SHARES_OWNED_BY                                :{WHITE}({COMMA}% owned by {COMPANY})

STR_COMPANY_VIEW_BUY_SHARE_BUTTON                               :{BLACK}Buy 25% share in company

STR_COMPANY_VIEW_SELL_SHARE_BUTTON                              :{BLACK}Sell 25% share in company

STR_COMPANY_VIEW_BUY_SHARE_TOOLTIP                              :{BLACK}Buy 25% share in this company. Shift+Click shows estimated cost without purchasing any share

STR_COMPANY_VIEW_SELL_SHARE_TOOLTIP                             :{BLACK}Sell 25% share in this company. Shift+Click shows estimated income without selling any share

STR_ERROR_CAN_T_BUY_25_SHARE_IN_THIS                            :{WHITE}Can't buy 25% share in this company...

STR_ERROR_CAN_T_SELL_25_SHARE_IN                                :{WHITE}Can't sell 25% share in this company...

STR_ERROR_PROTECTED                                             :{WHITE}This company is not old enough to trade shares yet...

static const byte NETWORK_GAME_ADMIN_VERSION        =    2;           ///< What version of the admin network do we use?

	for (auto owner : c->share_owners) {

		p->Send_uint8(owner);

	}

	for (auto owner : c->share_owners) {

		p->Send_uint8(owner);

	}

	if (IsSavegameVersionBefore(SLV_84)) {

		/* Set all share owners to INVALID_COMPANY for

		 * 1) all inactive companies

		 *     (when inactive companies were stored in the savegame - TTD, TTDP and some

		 *      *really* old revisions of OTTD; else it is already set in InitializeCompanies())

		 * 2) shares that are owned by inactive companies or self

		 *     (caused by cheating clients in earlier revisions) */

		for (Company *c : Company::Iterate()) {

			for (auto &share_owner : c->share_owners) {

				if (share_owner == INVALID_COMPANY) continue;

				if (!Company::IsValidID(share_owner) || share_owner == c->index) share_owner = INVALID_COMPANY;

			}

		}

	}

	    SLE_ARR(CompanyProperties, share_owners,          SLE_UINT8, 4),

	SLC_VAR("share_owners"),

	SLC_VAR("economy.allow_shares"),

	SLC_VAR("economy.min_years_for_shares"),

	OCL_SVAR( OC_TTD | OC_UINT8, Company, share_owners[0] ),

	OCL_SVAR( OC_TTD | OC_UINT8, Company, share_owners[1] ),

	OCL_SVAR( OC_TTD | OC_UINT8, Company, share_owners[2] ),

	OCL_SVAR( OC_TTD | OC_UINT8, Company, share_owners[3] ),

			ai->Add(new SettingEntry("economy.allow_shares"));

			ai->Add(new SettingEntry("economy.min_years_for_shares"));

	bool   allow_shares;                     ///< allow the buying/selling of shares

	uint8  min_years_for_shares;             ///< minimum age of a company for it to trade shares

[SDT_BOOL]

var      = economy.allow_shares

def      = false

str      = STR_CONFIG_SETTING_ALLOW_SHARES

strhelp  = STR_CONFIG_SETTING_ALLOW_SHARES_HELPTEXT

post_cb  = [](auto) { InvalidateWindowClassesData(WC_COMPANY); }

[SDT_VAR]

var      = economy.min_years_for_shares

type     = SLE_UINT8

from     = SLV_TRADING_AGE

flags    = SF_GUI_0_IS_SPECIAL

def      = 6

min      = 0

max      = 255

interval = 1

str      = STR_CONFIG_SETTING_MIN_YEARS_FOR_SHARES

strhelp  = STR_CONFIG_SETTING_MIN_YEARS_FOR_SHARES_HELPTEXT

strval   = STR_CONFIG_SETTING_MIN_YEARS_FOR_SHARES_VALUE

cat      = SC_EXPERT

	WID_C_SELECT_DESC_OWNERS,         ///< Owners.

	WID_C_DESC_OWNERS,                ///< Owner in Owners.

	WID_C_BUY_SHARE,                  ///< Button to buy a share.

	WID_C_SELL_SHARE,                 ///< Button to sell a share.