* @param include_initial_cargo_type if true the default cargo type of the vehicle is included; if false only the refit_mask

 * @return bit set of CargoIDs

 */

{

	const Engine *e = Engine::Get(engine);

	if (!e->CanCarryCargo()) return 0;

	if (include_initial_cargo_type) {

		SetBit(cargoes, e->GetDefaultCargoType());

 * @param[out] cargoes Total amount of units that can be transported, summed by cargo.

 * @param[out] refits Whether a (possibly partial) refit for each cargo is possible.

 */

{

	cargoes->Clear();

	*refits = 0;

 * @param union_mask returns bit mask of CargoIDs which are a refit option for at least one articulated part

 * @param intersection_mask returns bit mask of CargoIDs which are a refit option for every articulated part (with default capacity > 0)

 */

{

	const Engine *e = Engine::Get(engine);

	*union_mask = veh_cargoes;

	if (!e->IsGroundVehicle()) return;

	if (!HasBit(e->info.callback_mask, CBM_VEHICLE_ARTIC_ENGINE)) return;

 * @param include_initial_cargo_type if true the default cargo type of the vehicle is included; if false only the refit_mask

 * @return bit mask of CargoIDs which are a refit option for at least one articulated part

 */

{

	GetArticulatedRefitMasks(engine, include_initial_cargo_type, &union_mask, &intersection_mask);

	return union_mask;

}

 * @param include_initial_cargo_type if true the default cargo type of the vehicle is included; if false only the refit_mask

 * @return bit mask of CargoIDs which are a refit option for every articulated part (with default capacity > 0)

 */

{

	GetArticulatedRefitMasks(engine, include_initial_cargo_type, &union_mask, &intersection_mask);

	return intersection_mask;

}

{

	const Engine *engine = v->GetEngine();

	GetArticulatedRefitMasks(v->engine_type, true, &purchase_refit_union, &purchase_refit_intersection);

	CargoArray purchase_default_capacity = GetCapacityOfArticulatedParts(v->engine_type);

	CargoArray real_default_capacity;

	do {

		real_refit_union |= refit_mask;

		if (refit_mask != 0) real_refit_intersection &= refit_mask;

uint CountArticulatedParts(EngineID engine_type, bool purchase_window);

CargoArray GetCapacityOfArticulatedParts(EngineID engine);

void AddArticulatedParts(Vehicle *first);

bool IsArticulatedVehicleCarryingDifferentCargoes(const Vehicle *v, CargoID *cargo_type);

bool IsArticulatedVehicleRefittable(EngineID engine);

bool IsArticulatedEngine(EngineID engine_type);

 */

static bool EnginesHaveCargoInCommon(EngineID engine_a, EngineID engine_b)

{

	return (available_cargoes_a == 0 || available_cargoes_b == 0 || (available_cargoes_a & available_cargoes_b) != 0);

}

 */

static bool VerifyAutoreplaceRefitForOrders(const Vehicle *v, EngineID engine_type)

{

	const Order *o;

	const Vehicle *u = (v->type == VEH_TRAIN) ? v->First() : v;

 */

static CargoID GetNewCargoTypeForReplace(Vehicle *v, EngineID engine_type, bool part_of_chain)

{

	GetArticulatedRefitMasks(engine_type, true, &union_mask, &available_cargo_types);

	if (union_mask == 0) return CT_NO_REFIT; // Don't try to refit an engine with no cargo capacity

	uint16 random_bits;             ///< Random bits assigned to this station

	byte waiting_triggers;          ///< Waiting triggers (NewGRF) for this station

	uint8 cached_anim_triggers;     ///< NOSAVE: Combined animation trigger bitmask, used to determine if trigger processing should happen.

	TileArea train_station;         ///< Tile area the train 'station' part covers

	StationRect rect;               ///< NOSAVE: Station spread out rectangle maintained by StationRect::xxx() functions

static bool CDECL CargoFilter(const EngineID *eid, const CargoID cid)

{

	if (cid == CF_ANY) return true;

	return (cid == CF_NONE ? refit_mask == 0 : HasBit(refit_mask, cid));

}

static int DrawCargoCapacityInfo(int left, int right, int y, EngineID engine)

{

	CargoArray cap;

	GetArticulatedVehicleCargoesAndRefits(engine, &cap, &refits);

	for (CargoID c = 0; c < NUM_CARGO; c++) {

typedef byte CargoID;

/** Available types of cargo */

	/* Temperate */

	CT_PASSENGERS   =  0,

	CT_COAL         =  1,

	CT_INVALID      = 0xFF, ///< Invalid cargo type.

};

/** Class for storing amounts of cargo */

struct CargoArray {

private:

 * Bitmask of cargo types available. This includes phony cargoes like regearing cargoes.

 * Initialized during a call to #SetupCargoForClimate.

 */

/**

 * Bitmask of real cargo types available. Phony cargoes like regearing cargoes are excluded.

 */

/**

 * Set up the default cargo types for the given landscape type.

	friend void SetupCargoForClimate(LandscapeID l);

};

void SetupCargoForClimate(LandscapeID l);

CargoID GetCargoIDByLabel(CargoLabel cl);

		if ((var = CargoSpec::Get(cargospec_index))->IsValid())

#define FOR_ALL_CARGOSPECS(var) FOR_ALL_CARGOSPECS_FROM(var, 0)

/**

 * Loop header for iterating over cargoes, sorted by name. This includes phony cargoes like regearing cargoes.

struct PrepareRefitAction

{

	CargoArray &consist_capleft; ///< Capacities left in the consist.

	/**

	 * Create a refit preparation action.

	 * @param consist_capleft Capacities left in consist, to be updated here.

	 * @param refit_mask Refit mask to be constructed from refit information of vehicles.

	 */

		consist_capleft(consist_capleft), refit_mask(refit_mask) {}

	/**

	Backup<CompanyByte> cur_company(_current_company, v->owner, FILE_LINE);

	/* Remove old capacity from consist capacity and collect refit mask. */

	IterateVehicleParts(v_start, PrepareRefitAction(consist_capleft, refit_mask));

	bool completely_emptied = true;

	bool anything_unloaded  = false;

	bool anything_loaded    = false;

	front->cur_speed = 0;

				/* if the aircraft carries passengers and is NOT full, then

				 * continue loading, no matter how much mail is in */

				if ((front->type == VEH_AIRCRAFT && IsCargoInClass(front->cargo_type, CC_PASSENGERS) && front->cargo_cap > front->cargo.StoredCount()) ||

					finished_loading = false;

				}

			} else if (cargo_not_full != 0) {

	CompanyID best_company = INVALID_COMPANY;

	/* For trains the cargomask has no useful meaning, since you can attach other wagons */

	int32 best_hist = -1;

	const Company *c;

	/* Is there any cargo except the default cargo? */

	CargoID default_cargo = e->GetDefaultCargoType();

}

/**

bool IsEngineBuildable(EngineID engine, VehicleType type, CompanyID company);

bool IsEngineRefittable(EngineID engine);

void SetYearEngineAgingStops();

void StartupOneEngine(Engine *e, Date aging_date);

	byte load_amount;

	byte climates;      ///< Climates supported by the engine.

	CargoID cargo_type;

	byte refit_cost;

	byte misc_flags;    ///< Miscellaneous flags. @see EngineMiscFlags

	byte callback_mask; ///< Bitmask of vehicle callbacks that have to be called

	return FlatteningFoundation(tileh);

}

{

	IndustryGfx gfx = GetIndustryGfx(tile);

	const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);

 * Set a new cargo mask and rebuild the cache.

 * @param cargo_mask New cargo mask.

 */

{

	this->cargo_mask = cargo_mask;

	this->RebuildCache();

			this->SetWidgetLoweredState(WID_LGL_COMPANY_FIRST + c, HasBit(companies, c));

		}

	}

	for (uint c = 0; c < NUM_CARGO; c++) {

		if (!this->IsWidgetDisabled(WID_LGL_CARGO_FIRST + c)) {

			this->SetWidgetLoweredState(WID_LGL_CARGO_FIRST + c, HasBit(cargoes, c));

 */

void LinkGraphLegendWindow::UpdateOverlayCargoes()

{

	for (uint c = 0; c < NUM_CARGO; c++) {

		if (this->IsWidgetDisabled(c + WID_LGL_CARGO_FIRST)) continue;

		if (!this->IsWidgetLowered(c + WID_LGL_CARGO_FIRST)) continue;

	 * @param company_mask Bitmask of companies to be shown.

	 * @param scale Desired thickness of lines and size of station dots.

	 */

			window(w), widget_id(wid), cargo_mask(cargo_mask), company_mask(company_mask), scale(scale)

	{}

	void RebuildCache();

	void Draw(const DrawPixelInfo *dpi) const;

	void SetCompanyMask(uint32 company_mask);

	/** Get a bitmask of the currently shown cargoes. */

	/** Get a bitmask of the currently shown companies. */

	uint32 GetCompanyMask() { return this->company_mask; }

protected:

	const Window *window;              ///< Window to be drawn into.

	const uint widget_id;              ///< ID of Widget in Window to be drawn to.

	uint32 company_mask;               ///< Bitmask of companies to be displayed.

	LinkMap cached_links;              ///< Cache for links to reduce recalculation.

	StationSupplyList cached_stations; ///< Cache for stations to be drawn.

	Refittability refittability;     ///< Did the newgrf set any refittability property? If not, default refittability will be applied.

	bool prop27_set;         ///< Did the NewGRF set property 27 (misc flags)?

	uint8 rv_max_speed;      ///< Temporary storage of RV prop 15, maximum speed in mph/0.8

	/**

	 * Update the summary refittability on setting a refittability property.

}

/**

 */

	uint8 bit;

	FOR_EACH_SET_BIT(bit, refit_mask) {

		CargoID cargo = GetCargoTranslation(bit, _cur.grffile, true);

				uint8 count = buf->ReadByte();

				_gted[e->index].UpdateRefittability(prop == 0x2C && count != 0);

				if (prop == 0x2C) _gted[e->index].defaultcargo_grf = _cur.grffile;

				ctt = 0;

				while (count--) {

					CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);

				uint8 count = buf->ReadByte();

				_gted[e->index].UpdateRefittability(prop == 0x24 && count != 0);

				if (prop == 0x24) _gted[e->index].defaultcargo_grf = _cur.grffile;

				ctt = 0;

				while (count--) {

					CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);

				uint8 count = buf->ReadByte();

				_gted[e->index].UpdateRefittability(prop == 0x1E && count != 0);

				if (prop == 0x1E) _gted[e->index].defaultcargo_grf = _cur.grffile;

				ctt = 0;

				while (count--) {

					CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);

				uint8 count = buf->ReadByte();

				_gted[e->index].UpdateRefittability(prop == 0x1D && count != 0);

				if (prop == 0x1D) _gted[e->index].defaultcargo_grf = _cur.grffile;

				ctt = 0;

				while (count--) {

					CargoID ctype = GetCargoTranslation(buf->ReadByte(), _cur.grffile);

				break;

			case 0x12: // Cargo types for random triggers

				if (_cur.grffile->grf_version >= 7) {

				}

				break;

		/* Did the newgrf specify any refitting? If not, use defaults. */

		if (_gted[engine].refittability != GRFTempEngineData::UNSET) {

			/* If the original masks set by the grf are zero, the vehicle shall only carry the default cargo.

			 * Note: After applying the translations, the vehicle may end up carrying no defined cargo. It becomes unavailable in that case. */

			ei->refit_mask |= _gted[engine].ctt_include_mask;

			ei->refit_mask &= ~_gted[engine].ctt_exclude_mask;

		} else {

			/* Don't apply default refit mask to wagons nor engines with no capacity */

			if (e->type != VEH_TRAIN || (e->u.rail.capacity != 0 && e->u.rail.railveh_type != RAILVEH_WAGON)) {

 */

HouseResolverObject::HouseResolverObject(HouseID house_id, TileIndex tile, Town *town,

		CallbackID callback, uint32 param1, uint32 param2,

	: ResolverObject(GetHouseSpecGrf(house_id), callback, param1, param2),

	house_scope(*this, house_id, tile, town, not_yet_constructed, initial_random_bits, watched_cargo_triggers),

	town_scope(*this, town, not_yet_constructed) // Don't access StorePSA if house is not yet constructed.

}

uint16 GetHouseCallback(CallbackID callback, uint32 param1, uint32 param2, HouseID house_id, Town *town, TileIndex tile,

{

	assert(IsValidTile(tile) && (not_yet_constructed || IsTileType(tile, MP_HOUSE)));

}

/* Simple wrapper for GetHouseCallback to keep the animation unified. */

{

	return GetHouseCallback(callback, param1, param2, spec - HouseSpec::Get(0), town, tile, false, 0, extra_data);

}

/** Helper class for animation control. */

	static const CallbackID cb_animation_speed      = CBID_HOUSE_ANIMATION_SPEED;

	static const CallbackID cb_animation_next_frame = CBID_HOUSE_ANIMATION_NEXT_FRAME;

 * @param trigger_cargoes Cargo types that triggered the callback.

 * @param random Random bits.

 */

{

	TileIndexDiffC diff = TileIndexToTileIndexDiffC(origin, tile);

	uint32 cb_info = random << 16 | (uint8)diff.y << 8 | (uint8)diff.x;

 * @param trigger_cargoes Triggering cargo types.

 * @pre IsTileType(t, MP_HOUSE)

 */

{

	assert(IsTileType(tile, MP_HOUSE));

	HouseID id = GetHouseType(tile);

	Town *town;                    ///< Town of this house.

	bool not_yet_constructed;      ///< True for construction check.

	uint16 initial_random_bits;    ///< Random bits during construction checks.

	/**

	 * Constructor of a house scope resolver.

	 * @param watched_cargo_triggers Cargo types that triggered the watched cargo callback.

	 */

	HouseScopeResolver(ResolverObject &ro, HouseID house_id, TileIndex tile, Town *town,

		: ScopeResolver(ro), house_id(house_id), tile(tile), town(town), not_yet_constructed(not_yet_constructed),

		initial_random_bits(initial_random_bits), watched_cargo_triggers(watched_cargo_triggers)

	{

	HouseResolverObject(HouseID house_id, TileIndex tile, Town *town,

			CallbackID callback = CBID_NO_CALLBACK, uint32 param1 = 0, uint32 param2 = 0,

	/* virtual */ ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, byte relative = 0)

	{

void AnimateNewHouseConstruction(TileIndex tile);

uint16 GetHouseCallback(CallbackID callback, uint32 param1, uint32 param2, HouseID house_id, Town *town, TileIndex tile,

bool CanDeleteHouse(TileIndex tile);

	uint32 whole_reseed = 0;

	ETileArea area = ETileArea(st, tile, tas[trigger]);

	if (trigger == SRT_CARGO_TAKEN) {

		/* Create a bitmask of completely empty cargo types to be matched */

		for (CargoID i = 0; i < NUM_CARGO; i++) {

	 */

	uint16 cargo_threshold;

	byte callback_mask; ///< Bitmask of station callbacks that have to be called

	return cost;

}

{

	if (!IsObjectType(tile, OBJECT_HQ)) return;

		SlObject(&t->cargo_accepted, GetTileMatrixDesc());

		if (t->cargo_accepted.area.w != 0) {

			uint arr_len = t->cargo_accepted.area.w / AcceptanceMatrix::GRID * t->cargo_accepted.area.h / AcceptanceMatrix::GRID;

			SlArray(t->cargo_accepted.data, arr_len, SLE_UINT32);

			/* Rebuild total cargo acceptance. */

 */

void SmallMapWindow::SetOverlayCargoMask()

{

	for (int i = 0; i != _smallmap_cargo_count; ++i) {

		if (_legend_linkstats[i].show_on_map) SetBit(cargo_mask, _legend_linkstats[i].type);

	}

	byte last_vehicle_type;

	std::list<Vehicle *> loading_vehicles;

	GoodsEntry goods[NUM_CARGO];  ///< Goods at this station

	IndustryVector industries_near; ///< Cached list of industries near the station that can accept cargo, @see DeliverGoodsToIndustry()

 * @param st Station to query

 * @return the expected mask

 */

{

	for (CargoID i = 0; i < NUM_CARGO; i++) {

	}

	return mask;

}

 * @param rad Search radius in addition to given area

 * @param always_accepted bitmask of cargo accepted by houses and headquarters; can be NULL

 */

{

	CargoArray acceptance;

	if (always_accepted != NULL) *always_accepted = 0;

void UpdateStationAcceptance(Station *st, bool show_msg)

{

	/* old accepted goods types */

	/* And retrieve the acceptance. */

	CargoArray acceptance;

	}

	/* Only show a message in case the acceptance was actually changed. */

	if (old_acc == new_acc) return;

	/* show a message to report that the acceptance was changed? */

void TriggerWatchedCargoCallbacks(Station *st)

{

	/* Collect cargoes accepted since the last big tick. */

	for (CargoID cid = 0; cid < NUM_CARGO; cid++) {

		if (HasBit(st->goods[cid].status, GoodsEntry::GES_ACCEPTED_BIGTICK)) SetBit(cargoes, cid);

	}

void UpdateAllStationVirtCoords();

CargoArray GetProductionAroundTiles(TileIndex tile, int w, int h, int rad);

void UpdateStationAcceptance(Station *st, bool show_msg);

int DrawStationCoverageAreaText(int left, int right, int top, StationCoverageType sct, int rad, bool supplies)

{

	TileIndex tile = TileVirtXY(_thd.pos.x, _thd.pos.y);

	if (_thd.drawstyle == HT_RECT && tile < MapSize()) {

		CargoArray cargoes;

		if (supplies) {

	static Listing last_sorting;

	static byte facilities;               // types of stations of interest

	static bool include_empty;            // whether we should include stations without waiting cargo

	static const Station *last_station;

	/* Constants for sorting stations */

Listing CompanyStationsWindow::last_sorting = {false, 0};

byte CompanyStationsWindow::facilities = FACIL_TRAIN | FACIL_TRUCK_STOP | FACIL_BUS_STOP | FACIL_AIRPORT | FACIL_DOCK;

bool CompanyStationsWindow::include_empty = true;

const Station *CompanyStationsWindow::last_station = NULL;

/* Availible station sorting functions */

	{

		const Station *st = Station::Get(this->window_number);