{     120, 100}, // SCORE_VEHICLES

	{      80, 100}, // SCORE_STATIONS

	{   10000, 100}, // SCORE_MIN_PROFIT

	{   50000,  50}, // SCORE_MIN_INCOME

	{  100000, 100}, // SCORE_MAX_INCOME

	{   40000, 400}, // SCORE_DELIVERED

	{       8,  50}, // SCORE_CARGO

	{10000000,  50}, // SCORE_MONEY

	{  250000,  50}, // SCORE_LOAN

	{       0,   0}  // SCORE_TOTAL

};

Economy _economy;

Prices _price;

Money _additional_cash_required;

static PriceMultipliers _price_base_multiplier;

/**

 * Calculate the value of the company. That is the value of all

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

 * except when including_loan is \c false which is useful when

 * we want to calculate the value for bankruptcy.

 * @param c              the company to get the value of.

 * @param including_loan include the loan in the company value.

						min_profit = v->profit_last_year;

						min_profit_first = false;

					}

				}

			}

		}

		min_profit >>= 8; // remove the fract part

		_score_part[owner][SCORE_VEHICLES] = num;

		/* Don't allow negative min_profit to show */

		if (min_profit > 0) {

		}

	}

	/* Count stations */

	{

		uint num = 0;

		const Station *st;

		FOR_ALL_STATIONS(st) {

			/* Only count stations that are actually serviced */

			if (st->owner == owner && (st->time_since_load <= 20 || st->time_since_unload <= 20)) num += CountBits((byte)st->facilities);

		}

		int numec = min(c->num_valid_stat_ent, 12);

		if (numec != 0) {

			const CompanyEconomyEntry *cee = c->old_economy;

			Money min_income = cee->income + cee->expenses;

			Money max_income = cee->income + cee->expenses;

			do {

				min_income = min(min_income, cee->income + cee->expenses);

				max_income = max(max_income, cee->income + cee->expenses);

			} while (++cee, --numec);

			if (min_income > 0) {

			}

		}

	}

	/* Generate score depending on amount of transported cargo */

	{

		int numec = min(c->num_valid_stat_ent, 4);

		if (numec != 0) {

			const CompanyEconomyEntry *cee = c->old_economy;

			OverflowSafeInt64 total_delivered = 0;

			do {

				total_delivered += cee->delivered_cargo.GetSum<OverflowSafeInt64>();

			} while (++cee, --numec);

		}

	}

	/* Generate score for variety of cargo */

	{

		_score_part[owner][SCORE_CARGO] = c->old_economy->delivered_cargo.GetCount();

	}

	/* Generate score for company's money */

	{

		if (c->money > 0) {

		}

	}

	/* Generate score for loan */

	{

	}

	/* Now we calculate the score for each item.. */

	{

		int total_score = 0;

		int s;

		score = 0;

		for (ScoreID i = SCORE_BEGIN; i < SCORE_END; i++) {

			/* Skip the total */

			if (i == SCORE_TOTAL) continue;

			/*  Check the score */

			s = Clamp(_score_part[owner][i], 0, _score_info[i].needed) * _score_info[i].score / _score_info[i].needed;

#define ECONOMY_FUNC_H

#include "economy_type.h"

#include "station_type.h"

#include "cargo_type.h"

#include "vehicle_type.h"

#include "company_type.h"

void ResetPriceBaseMultipliers();

void SetPriceBaseMultiplier(Price price, int factor);

extern const ScoreInfo _score_info[];

extern Economy _economy;

/* Prices and also the fractional part. */

extern Prices _price;

int UpdateCompanyRatingAndValue(Company *c, bool update);

void StartupIndustryDailyChanges(bool init_counter);

Money GetTransportedGoodsIncome(uint num_pieces, uint dist, byte transit_days, CargoID cargo_type);

uint MoveGoodsToStation(CargoID type, uint amount, SourceType source_type, SourceID source_id, const StationList *all_stations);

void PrepareUnload(Vehicle *front_v);

void LoadUnloadStation(Station *st);

			return;

		}

		if (!IsInsideMM(widget, WID_PRD_SCORE_FIRST, WID_PRD_SCORE_LAST + 1)) return;

		ScoreID score_type = (ScoreID)(widget - WID_PRD_SCORE_FIRST);

		/* The colours used to show how the progress is going */

		int colour_done = _colour_gradient[COLOUR_GREEN][4];

		int colour_notdone = _colour_gradient[COLOUR_RED][4];

		/* Draw all the score parts */

		/* SCORE_TOTAL has his own rules ;) */

		if (score_type == SCORE_TOTAL) {

			for (ScoreID i = SCORE_BEGIN; i < SCORE_END; i++) score += _score_info[i].score;

			needed = SCORE_MAX;

		}

		uint bar_top  = r.top + WD_MATRIX_TOP;

		uint text_top = bar_top + 2;

		DrawString(this->score_info_left, this->score_info_right, text_top, STR_PERFORMANCE_DETAIL_VEHICLES + score_type);

		/* Draw the score */

		SetDParam(0, score);

		DrawString(this->score_info_left, this->score_info_right, text_top, STR_BLACK_COMMA, TC_FROMSTRING, SA_RIGHT);

		/* Calculate the %-bar */

		bool rtl = _current_text_dir == TD_RTL;

		if (rtl) {

			x = this->bar_right - x;

		} else {

			x = this->bar_left + x;

		}

		/* Draw the bar */

		if (x != this->bar_left)  GfxFillRect(this->bar_left, bar_top, x, bar_top + this->bar_height, rtl ? colour_notdone : colour_done);

		if (x != this->bar_right) GfxFillRect(x, bar_top, this->bar_right, bar_top + this->bar_height, rtl ? colour_done : colour_notdone);

		/* Draw it */

		DrawString(this->bar_left, this->bar_right, text_top, STR_PERFORMANCE_DETAIL_PERCENT, TC_FROMSTRING, SA_HOR_CENTER);

		/* SCORE_LOAN is inversed */

		if (score_type == SCORE_LOAN) val = needed - val;

		/* Draw the amount we have against what is needed

		 * For some of them it is in currency format */

		SetDParam(0, val);

		SetDParam(1, needed);

		switch (score_type) {

			case SCORE_MIN_PROFIT:

			case SCORE_MIN_INCOME: