openttd-ottdgrfs: comparison src/economy.cpp

equal deleted inserted replaced

-:ca3fd1fbe311
+:5a9dc001e1ad
 #include "date.h"
 #include "cargotype.h"
 #include "player_face.h"
 #include "group.h"
+/**
+* Multiply two integer values and shift the results to right.
+*
+* This function multiplies two integer values. The result is
+* shifted by the amount of shift to right.
+*
+* @param a The first integer
+* @param b The second integer
+* @param shift The amount to shift the value to right.
+* @return The shifted result
+*/
+static inline int32 BigMulS(const int32 a, const int32 b, const uint8 shift)
+{
+	return (int32)((int64)a * (int64)b >> shift);
+}
+/**
+* Multiply two unsigned integers and shift the results to right.
+*
+* This function multiplies two unsigned integers. The result is
+* shifted by the amount of shift to right.
+*
+* @param a The first unsigned integer
+* @param b The second unsigned integer
+* @param shift The amount to shift the value to right.
+* @return The shifted result
+*/
+static inline uint32 BigMulSU(const uint32 a, const uint32 b, const uint8 shift)
+{
+	return (uint32)((uint64)a * (uint64)b >> shift);
+}
 /* Score info */
 const ScoreInfo _score_info[] = {
 	{ SCORE_VEHICLES,        120, 100 },
 	{ SCORE_STATIONS,         80, 100 },
 	{ SCORE_MIN_PROFIT,    10000, 100 },
 Money CalculateCompanyValue(const Player* p)
 {
 	PlayerID owner = p->index;
 	/* Do a little nasty by using CommandCost, so we can use the "overflow" protection of CommandCost */
-	CommandCost value;
+	Money value = 0;
-	{
+	Station *st;
-		Station *st;
+	uint num = 0;
-		uint num = 0;
+	FOR_ALL_STATIONS(st) {
-		FOR_ALL_STATIONS(st) {
+		if (st->owner == owner) num += CountBits(st->facilities);
-			if (st->owner == owner) num += COUNTBITS(st->facilities);
+	}
-		}
+	value += num * _price.station_value * 25;
-		value.AddCost(num * _price.station_value * 25);
-	}
+	Vehicle *v;
+	FOR_ALL_VEHICLES(v) {
-	{
+		if (v->owner != owner) continue;
-		Vehicle *v;
+		if (v->type == VEH_TRAIN ||
-		FOR_ALL_VEHICLES(v) {
+				v->type == VEH_ROAD ||
-			if (v->owner != owner) continue;
+				(v->type == VEH_AIRCRAFT && IsNormalAircraft(v)) ||
+				v->type == VEH_SHIP) {
-			if (v->type == VEH_TRAIN ||
+			value += v->value * 3 >> 1;
-					v->type == VEH_ROAD ||
-					(v->type == VEH_AIRCRAFT && IsNormalAircraft(v)) ||
-					v->type == VEH_SHIP) {
-				value.AddCost(v->value * 3 >> 1);
-			}
 		}
 	}
 	/* Add real money value */
-	value.AddCost(-p->current_loan);
+	value -= p->current_loan;
-	value.AddCost(p->player_money);
+	value += p->player_money;
-	return max(value.GetCost(), 1LL);
+	return max(value, (Money)1);
 }
 /** if update is set to true, the economy is updated with this score
 *  (also the house is updated, should only be true in the on-tick event)
 * @param update the economy with calculated score
 	{
 		uint num = 0;
 		const Station* st;
 		FOR_ALL_STATIONS(st) {
-			if (st->owner == owner) num += COUNTBITS(st->facilities);
+			if (st->owner == owner) num += CountBits(st->facilities);
 		}
 		_score_part[owner][SCORE_STATIONS] = num;
 	}
 /* Generate statistics depending on recent income statistics */
 		}
 	}
 /* Generate score for variety of cargo */
 	{
-		uint num = COUNTBITS(p->cargo_types);
+		uint num = CountBits(p->cargo_types);
 		_score_part[owner][SCORE_CARGO] = num;
 		if (update) p->cargo_types = 0;
 	}
 /* Generate score for player money */
 		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;
+			s = Clamp(_score_part[owner][i], 0, _score_info[i].needed) * _score_info[i].score / _score_info[i].needed;
 			score += s;
 			total_score += _score_info[i].score;
 		}
 		_score_part[owner][SCORE_TOTAL] = score;
 	/* Take care of rating in towns */
 	FOR_ALL_TOWNS(t) {
 		/* If a player takes over, give the ratings to that player. */
 		if (new_player != PLAYER_SPECTATOR) {
-			if (HASBIT(t->have_ratings, old_player)) {
+			if (HasBit(t->have_ratings, old_player)) {
-				if (HASBIT(t->have_ratings, new_player)) {
+				if (HasBit(t->have_ratings, new_player)) {
 					// use max of the two ratings.
 					t->ratings[new_player] = max(t->ratings[new_player], t->ratings[old_player]);
 				} else {
-					SETBIT(t->have_ratings, new_player);
+					SetBit(t->have_ratings, new_player);
 					t->ratings[new_player] = t->ratings[old_player];
 				}
 			}
 		}
 		/* Reset the ratings for the old player */
 		t->ratings[old_player] = 500;
-		CLRBIT(t->have_ratings, old_player);
+		ClrBit(t->have_ratings, old_player);
 	}
 	{
 		int num_train = 0;
 		int num_road = 0;
 				}
 			}
 		}
 		FOR_ALL_VEHICLES(v) {
-			if (v->owner == old_player && IS_BYTE_INSIDE(v->type, VEH_TRAIN, VEH_AIRCRAFT + 1)) {
+			if (v->owner == old_player && IsInsideMM(v->type, VEH_TRAIN, VEH_AIRCRAFT + 1)) {
 				if (new_player == PLAYER_SPECTATOR) {
 					DeleteWindowById(WC_VEHICLE_VIEW, v->index);
 					DeleteWindowById(WC_VEHICLE_DETAILS, v->index);
 					DeleteWindowById(WC_VEHICLE_ORDERS, v->index);
 	DrawStringMultiCenter(49, 148, STR_7058_PRESIDENT, 94);
 	switch (ni->string_id & 0xF0) {
 	case NB_BTROUBLE:
-		DrawStringCentered(w->width >> 1, 1, STR_7056_TRANSPORT_COMPANY_IN_TROUBLE, 0);
+		DrawStringCentered(w->width >> 1, 1, STR_7056_TRANSPORT_COMPANY_IN_TROUBLE, TC_FROMSTRING);
 		SetDParam(0, p->index);
 		DrawStringMultiCenter(
 			((w->width - 101) >> 1) + 98,
 			STR_7057_WILL_BE_SOLD_OFF_OR_DECLARED,
 			w->width - 101);
 		break;
 	case NB_BMERGER:
-		DrawStringCentered(w->width >> 1, 1, STR_7059_TRANSPORT_COMPANY_MERGER, 0);
+		DrawStringCentered(w->width >> 1, 1, STR_7059_TRANSPORT_COMPANY_MERGER, TC_FROMSTRING);
 		SetDParam(0, ni->params[0]);
 		SetDParam(1, p->index);
 		SetDParam(2, ni->params[1]);
 		DrawStringMultiCenter(
 			((w->width - 101) >> 1) + 98,
 			ni->params[1] == 0 ? STR_707F_HAS_BEEN_TAKEN_OVER_BY : STR_705A_HAS_BEEN_SOLD_TO_FOR,
 			w->width - 101);
 		break;
 	case NB_BBANKRUPT:
-		DrawStringCentered(w->width >> 1, 1, STR_705C_BANKRUPT, 0);
+		DrawStringCentered(w->width >> 1, 1, STR_705C_BANKRUPT, TC_FROMSTRING);
 		SetDParam(0, ni->params[0]);
 		DrawStringMultiCenter(
 			((w->width - 101) >> 1) + 98,
 			90,
 			STR_705D_HAS_BEEN_CLOSED_DOWN_BY,
 			w->width - 101);
 		break;
 	case NB_BNEWCOMPANY:
-		DrawStringCentered(w->width >> 1, 1, STR_705E_NEW_TRANSPORT_COMPANY_LAUNCHED, 0);
+		DrawStringCentered(w->width >> 1, 1, STR_705E_NEW_TRANSPORT_COMPANY_LAUNCHED, TC_FROMSTRING);
 		SetDParam(0, p->index);
 		SetDParam(1, ni->params[0]);
 		DrawStringMultiCenter(
 			((w->width - 101) >> 1) + 98,
 			90,
 		_current_player = st->owner;
 		SET_EXPENSES_TYPE(EXPENSES_PROPERTY);
 		SubtractMoneyFromPlayer(_price.station_value >> 1);
 	}
-	if (!HASBIT(1<<0|1<<3|1<<6|1<<9, _cur_month))
+	if (!HasBit(1<<0|1<<3|1<<6|1<<9, _cur_month))
 		return;
 	FOR_ALL_PLAYERS(p) {
 		if (p->is_active) {
 			memmove(&p->old_economy[1], &p->old_economy[0], sizeof(p->old_economy) - sizeof(p->old_economy[0]));
 		if (!p->is_active) continue;
 		_current_player = p->index;
 		SET_EXPENSES_TYPE(EXPENSES_LOAN_INT);
-		SubtractMoneyFromPlayer(CommandCost((Money)BIGMULUS(p->current_loan, interest, 16)));
+		SubtractMoneyFromPlayer(CommandCost((Money)BigMulSU(p->current_loan, interest, 16)));
 		SET_EXPENSES_TYPE(EXPENSES_OTHER);
 		SubtractMoneyFromPlayer(_price.station_value >> 2);
 	}
 }
 	 700000, ///< aircraft_base
 	  14000, ///< roadveh_base
 	  65000, ///< ship_base
 	     20, ///< build_trees
 	    250, ///< terraform
-	     20, ///< clear_1
+	     20, ///< clear_grass
-	     40, ///< purchase_land
+	     40, ///< clear_roughland
-	    200, ///< clear_2
+	    200, ///< clear_rocks
-	    500, ///< clear_3
+	    500, ///< clear_fields
 	     20, ///< remove_trees
 	    -70, ///< remove_rail
 	     10, ///< remove_signals
 	     50, ///< clear_bridge
 	     80, ///< remove_train_depot
 	fr->from = i = GetRandomIndustry();
 	if (i == NULL) return;
 	/* Randomize cargo type */
-	if (HASBIT(Random(), 0) && i->produced_cargo[1] != CT_INVALID) {
+	if (HasBit(Random(), 0) && i->produced_cargo[1] != CT_INVALID) {
 		cargo = i->produced_cargo[1];
 		trans = i->last_month_pct_transported[1];
 		total = i->last_month_production[1];
 	} else {
 		cargo = i->produced_cargo[0];
 			s->age++;
 		}
 	}
 	/* 25% chance to go on */
-	if (CHANCE16(1,4)) {
+	if (Chance16(1,4)) {
 		/*  Find a free slot*/
 		s = _subsidies;
 		while (s->cargo_type != CT_INVALID) {
 			if (++s == endof(_subsidies))
 				goto no_add;
 Money GetTransportedGoodsIncome(uint num_pieces, uint dist, byte transit_days, CargoID cargo_type)
 {
 	const CargoSpec *cs = GetCargo(cargo_type);
 	/* Use callback to calculate cargo profit, if available */
-	if (HASBIT(cs->callback_mask, CBM_CARGO_PROFIT_CALC)) {
+	if (HasBit(cs->callback_mask, CBM_CARGO_PROFIT_CALC)) {
 		uint32 var18 = min(dist, 0xFFFF) | (min(num_pieces, 0xFF) << 16) | (transit_days << 24);
 		uint16 callback = GetCargoCallback(CBID_CARGO_PROFIT_CALC, 0, var18, cs);
 		if (callback != CALLBACK_FAILED) {
 			int result = GB(callback, 0, 14);
 			/* Simulate a 15 bit signed value */
-			if (HASBIT(callback, 14)) result = 0x4000 - result;
+			if (HasBit(callback, 14)) result = 0x4000 - result;
 			/* "The result should be a signed multiplier that gets multiplied
 			 * by the amount of cargo moved and the price factor, then gets
 			 * divided by 8192." */
 			return result * num_pieces * _cargo_payment_rates[cargo_type] / 8192;
 		time_factor = MAX_TIME_FACTOR - 2 * days_over_days1 + days2;
 	}
 	if (time_factor < MIN_TIME_FACTOR) time_factor = MIN_TIME_FACTOR;
-	return BIGMULSS(dist * time_factor * num_pieces, _cargo_payment_rates[cargo_type], 21);
+	return BigMulS(dist * time_factor * num_pieces, _cargo_payment_rates[cargo_type], 21);
 }
 static void DeliverGoodsToIndustry(TileIndex xy, CargoID cargo_type, int num_pieces)
 {
 	Industry *best = NULL;
 		}
 		/* Check if matching cargo has been found */
 		if (i == lengthof(ind->accepts_cargo)) continue;
-		if (HASBIT(indspec->callback_flags, CBM_IND_REFUSE_CARGO)) {
+		if (HasBit(indspec->callback_flags, CBM_IND_REFUSE_CARGO)) {
 			uint16 res = GetIndustryCallback(CBID_INDUSTRY_REFUSE_CARGO, 0, GetReverseCargoTranslation(cargo_type, indspec->grf_prop.grffile), ind, ind->type, ind->xy);
 			if (res == 0) continue;
 		}
 		uint dist = DistanceManhattan(ind->xy, xy);
 		uint16 callback = indspec->callback_flags;
 		best->was_cargo_delivered = true;
 		best->last_cargo_accepted_at = _date;
-		if (HASBIT(callback, CBM_IND_PRODUCTION_CARGO_ARRIVAL) || HASBIT(callback, CBM_IND_PRODUCTION_256_TICKS)) {
+		if (HasBit(callback, CBM_IND_PRODUCTION_CARGO_ARRIVAL) || HasBit(callback, CBM_IND_PRODUCTION_256_TICKS)) {
 			best->incoming_cargo_waiting[accepted_cargo_index] = min(num_pieces + best->incoming_cargo_waiting[accepted_cargo_index], 0xFFFF);
-			if (HASBIT(callback, CBM_IND_PRODUCTION_CARGO_ARRIVAL)) {
+			if (HasBit(callback, CBM_IND_PRODUCTION_CARGO_ARRIVAL)) {
 				IndustryProductionCallback(best, 0);
 			} else {
 				InvalidateWindow(WC_INDUSTRY_VIEW, best->index);
 			}
 		} else {
 			best->produced_cargo_waiting[0] = min(best->produced_cargo_waiting[0] + (num_pieces * indspec->input_cargo_multiplier[accepted_cargo_index][0] / 256), 0xFFFF);
 			best->produced_cargo_waiting[1] = min(best->produced_cargo_waiting[1] + (num_pieces * indspec->input_cargo_multiplier[accepted_cargo_index][1] / 256), 0xFFFF);
 		}
+		TriggerIndustry(best, INDUSTRY_TRIGGER_RECEIVED_CARGO);
 		StartStopIndustryTileAnimation(best, IAT_INDUSTRY_RECEIVED_CARGO);
 	}
 }
 static bool CheckSubsidised(Station *from, Station *to, CargoID cargo_type)
 	/* Update player statistics */
 	{
 		Player *p = GetPlayer(_current_player);
 		p->cur_economy.delivered_cargo += num_pieces;
-		SETBIT(p->cargo_types, cargo_type);
+		SetBit(p->cargo_types, cargo_type);
 	}
 	/* Get station pointers. */
 	s_from = GetStation(source);
 	s_to = GetStation(dest);
 	/* The owner of the train wants to be paid */
 	PlayerID old_player = _current_player;
 	_current_player = front_v->owner;
 	/* At this moment loading cannot be finished */
-	CLRBIT(front_v->vehicle_flags, VF_LOADING_FINISHED);
+	ClrBit(front_v->vehicle_flags, VF_LOADING_FINISHED);
 	/* Start unloading in at the first possible moment */
 	front_v->load_unload_time_rem = 1;
 	for (Vehicle *v = front_v; v != NULL; v = v->Next()) {
 		/* No cargo to unload */
 		if (v->cargo_cap == 0 || v->cargo.Empty()) continue;
 		/* All cargo has already been paid for, no need to pay again */
 		if (!v->cargo.UnpaidCargo()) {
-			SETBIT(v->vehicle_flags, VF_CARGO_UNLOADING);
+			SetBit(v->vehicle_flags, VF_CARGO_UNLOADING);
 			continue;
 		}
 		GoodsEntry *ge = &st->goods[v->cargo_type];
 		const CargoList::List *cargos = v->cargo.Packets();
 		for (CargoList::List::const_iterator it = cargos->begin(); it != cargos->end(); it++) {
 			CargoPacket *cp = *it;
 			if (!cp->paid_for &&
 					cp->source != last_visited &&
-					HASBIT(ge->acceptance_pickup, GoodsEntry::ACCEPTANCE) &&
+					HasBit(ge->acceptance_pickup, GoodsEntry::ACCEPTANCE) &&
 					(front_v->current_order.flags & OF_TRANSFER) == 0) {
 				/* Deliver goods to the station */
 				st->time_since_unload = 0;
 				/* handle end of route payment */
 				route_profit   += profit; // display amount paid for final route delivery, A-D of a chain A-B-C-D
 				vehicle_profit += profit - cp->feeder_share;                    // whole vehicle is not payed for transfers picked up earlier
 				result |= 1;
-				SETBIT(v->vehicle_flags, VF_CARGO_UNLOADING);
+				SetBit(v->vehicle_flags, VF_CARGO_UNLOADING);
 			} else if (front_v->current_order.flags & (OF_UNLOAD | OF_TRANSFER)) {
 				if (!cp->paid_for && (front_v->current_order.flags & OF_TRANSFER) != 0) {
 					Money profit = GetTransportedGoodsIncome(
 						cp->count,
 						/* pay transfer vehicle for only the part of transfer it has done: ie. cargo_loaded_at_xy to here */
 					cp->feeder_share += profit; // account for the (virtual) profit already made for the cargo packet
 					cp->paid_for      = true;   // record that the cargo has been paid for to eliminate double counting
 				}
 				result |= 2;
-				SETBIT(v->vehicle_flags, VF_CARGO_UNLOADING);
+				SetBit(v->vehicle_flags, VF_CARGO_UNLOADING);
 			}
 		}
 		v->cargo.InvalidateCache();
 	}
 {
 	assert(v->current_order.type == OT_LOADING);
 	/* We have not waited enough time till the next round of loading/unloading */
 	if (--v->load_unload_time_rem != 0) {
-		if (_patches.improved_load && HASBIT(v->current_order.flags, OFB_FULL_LOAD)) {
+		if (_patches.improved_load && HasBit(v->current_order.flags, OFB_FULL_LOAD)) {
 			/* 'Reserve' this cargo for this vehicle, because we were first. */
 			for (; v != NULL; v = v->Next()) {
 				if (v->cargo_cap != 0) cargo_left[v->cargo_type] -= v->cargo_cap - v->cargo.Count();
 			}
 		}
 	}
 	if (v->type == VEH_TRAIN && !IsTileType(v->tile, MP_STATION)) {
 		/* The train reversed in the station. Take the "easy" way
 		 * out and let the train just leave as it always did. */
-		SETBIT(v->vehicle_flags, VF_LOADING_FINISHED);
+		SetBit(v->vehicle_flags, VF_LOADING_FINISHED);
 		return;
 	}
 	int unloading_time = 0;
 	Vehicle *u = v;
 	for (; v != NULL; v = v->Next()) {
 		if (v->cargo_cap == 0) continue;
 		byte load_amount = EngInfo(v->engine_type)->load_amount;
-		if (_patches.gradual_loading && HASBIT(EngInfo(v->engine_type)->callbackmask, CBM_VEHICLE_LOAD_AMOUNT)) {
+		if (_patches.gradual_loading && HasBit(EngInfo(v->engine_type)->callbackmask, CBM_VEHICLE_LOAD_AMOUNT)) {
 			uint16 cb_load_amount = GetVehicleCallback(CBID_VEHICLE_LOAD_AMOUNT, 0, 0, v->engine_type, v);
-			if (cb_load_amount != CALLBACK_FAILED) load_amount = cb_load_amount & 0xFF;
+			if (cb_load_amount != CALLBACK_FAILED && cb_load_amount != 0) load_amount = cb_load_amount & 0xFF;
 		}
 		GoodsEntry *ge = &st->goods[v->cargo_type];
-		if (HASBIT(v->vehicle_flags, VF_CARGO_UNLOADING)) {
+		if (HasBit(v->vehicle_flags, VF_CARGO_UNLOADING)) {
 			uint cargo_count = v->cargo.Count();
 			uint amount_unloaded = _patches.gradual_loading ? min(cargo_count, load_amount) : cargo_count;
 			bool remaining; // Are there cargo entities in this vehicle that can still be unloaded here?
-			if (HASBIT(ge->acceptance_pickup, GoodsEntry::ACCEPTANCE) && !(u->current_order.flags & OF_TRANSFER)) {
+			if (HasBit(ge->acceptance_pickup, GoodsEntry::ACCEPTANCE) && !(u->current_order.flags & OF_TRANSFER)) {
 				/* The cargo has reached it's final destination, the packets may now be destroyed */
 				remaining = v->cargo.MoveTo(NULL, amount_unloaded, CargoList::MTA_FINAL_DELIVERY, last_visited);
 				result |= 1;
 			} else if (u->current_order.flags & (OF_UNLOAD | OF_TRANSFER)) {
 				remaining = v->cargo.MoveTo(&ge->cargo, amount_unloaded);
-				SETBIT(ge->acceptance_pickup, GoodsEntry::PICKUP);
+				SetBit(ge->acceptance_pickup, GoodsEntry::PICKUP);
 				result |= 2;
 			} else {
 				/* The order changed while unloading (unset unload/transfer) or the
 				 * station does not accept goods anymore. */
-				CLRBIT(v->vehicle_flags, VF_CARGO_UNLOADING);
+				ClrBit(v->vehicle_flags, VF_CARGO_UNLOADING);
 				continue;
 			}
 			/* Deliver goods to the station */
 			st->time_since_unload = 0;
 			anything_unloaded = true;
 			if (_patches.gradual_loading && remaining) {
 				completely_empty = false;
 			} else {
 				/* We have finished unloading (cargo count == 0) */
-				CLRBIT(v->vehicle_flags, VF_CARGO_UNLOADING);
+				ClrBit(v->vehicle_flags, VF_CARGO_UNLOADING);
 			}
 			continue;
 		}
 			uint count = ge->cargo.Count();
 			/* Skip loading this vehicle if another train/vehicle is already handling
 			 * the same cargo type at this station */
 			if (_patches.improved_load && cargo_left[v->cargo_type] <= 0) {
-				SETBIT(cargo_not_full, v->cargo_type);
+				SetBit(cargo_not_full, v->cargo_type);
 				continue;
 			}
 			if (cap > count) cap = count;
 			if (_patches.gradual_loading) cap = min(cap, load_amount);
 			result |= 2;
 		}
 		if (v->cargo.Count() == v->cargo_cap) {
-			SETBIT(cargo_full, v->cargo_type);
+			SetBit(cargo_full, v->cargo_type);
 		} else {
-			SETBIT(cargo_not_full, v->cargo_type);
+			SetBit(cargo_not_full, v->cargo_type);
 		}
 	}
 	/* We update these variables here, so gradual loading still fills
 	 * all wagons at the same time instead of using the same 'improved'
 	 * loading algorithm for the wagons (only fill wagon when there is
 	 * enough to fill the previous wagons) */
-	if (_patches.improved_load && HASBIT(u->current_order.flags, OFB_FULL_LOAD)) {
+	if (_patches.improved_load && HasBit(u->current_order.flags, OFB_FULL_LOAD)) {
 		/* Update left cargo */
 		for (v = u; v != NULL; v = v->Next()) {
 			if (v->cargo_cap != 0) cargo_left[v->cargo_type] -= v->cargo_cap - v->cargo.Count();
 		}
 	}
 			unloading_time = gradual_loading_wait_time[v->type];
 		}
 	} else {
 		bool finished_loading = true;
-		if (HASBIT(v->current_order.flags, OFB_FULL_LOAD)) {
+		if (HasBit(v->current_order.flags, OFB_FULL_LOAD)) {
 			if (_patches.full_load_any) {
 				/* if the aircraft carries passengers and is NOT full, then
 				 * continue loading, no matter how much mail is in */
 				if ((v->type == VEH_AIRCRAFT && IsCargoInClass(v->cargo_type, CC_PASSENGERS) && v->cargo_cap != v->cargo.Count()) ||
 						(cargo_not_full && (cargo_full & ~cargo_not_full) == 0)) { // There are stull non-full cargos

branch	NewGRF_ports
changeset 6871	5a9dc001e1ad
parent 6870	ca3fd1fbe311
child 6872	1c4a4a609f85