|
@@ -235,197 +235,199 @@ int UpdateCompanyRatingAndValue(Company
|
|
|
uint num = CountBits(c->cargo_types);
|
|
|
_score_part[owner][SCORE_CARGO] = num;
|
|
|
if (update) c->cargo_types = 0;
|
|
|
}
|
|
|
|
|
|
/* Generate score for company's money */
|
|
|
{
|
|
|
if (c->money > 0) {
|
|
|
_score_part[owner][SCORE_MONEY] = ClampToI32(c->money);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Generate score for loan */
|
|
|
{
|
|
|
_score_part[owner][SCORE_LOAN] = ClampToI32(_score_info[SCORE_LOAN].needed - c->current_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;
|
|
|
score += s;
|
|
|
total_score += _score_info[i].score;
|
|
|
}
|
|
|
|
|
|
_score_part[owner][SCORE_TOTAL] = score;
|
|
|
|
|
|
/* We always want the score scaled to SCORE_MAX (1000) */
|
|
|
if (total_score != SCORE_MAX) score = score * SCORE_MAX / total_score;
|
|
|
}
|
|
|
|
|
|
if (update) {
|
|
|
c->old_economy[0].performance_history = score;
|
|
|
UpdateCompanyHQ(c, score);
|
|
|
c->old_economy[0].company_value = CalculateCompanyValue(c);
|
|
|
}
|
|
|
|
|
|
InvalidateWindow(WC_PERFORMANCE_DETAIL, 0);
|
|
|
return score;
|
|
|
}
|
|
|
|
|
|
/* use INVALID_OWNER as new_owner to delete the company. */
|
|
|
void ChangeOwnershipOfCompanyItems(Owner old_owner, Owner new_owner)
|
|
|
{
|
|
|
Town *t;
|
|
|
CompanyID old = _current_company;
|
|
|
|
|
|
assert(old_owner != new_owner);
|
|
|
|
|
|
{
|
|
|
Company *c;
|
|
|
uint i;
|
|
|
|
|
|
/* See if the old_owner had shares in other companies */
|
|
|
_current_company = old_owner;
|
|
|
FOR_ALL_COMPANIES(c) {
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
if (c->share_owners[i] == old_owner) {
|
|
|
/* Sell his shares */
|
|
|
CommandCost res = DoCommand(0, c->index, 0, DC_EXEC, CMD_SELL_SHARE_IN_COMPANY);
|
|
|
/* Because we are in a DoCommand, we can't just execute an other 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 */
|
|
|
c = Company::Get(old_owner);
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
_current_company = c->share_owners[i];
|
|
|
if (_current_company != INVALID_OWNER) {
|
|
|
/* Sell the shares */
|
|
|
CommandCost res = DoCommand(0, old_owner, 0, DC_EXEC, CMD_SELL_SHARE_IN_COMPANY);
|
|
|
/* Because we are in a DoCommand, we can't just execute an other one and
|
|
|
* expect the money to be removed. We need to do it ourself! */
|
|
|
SubtractMoneyFromCompany(res);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
_current_company = old_owner;
|
|
|
|
|
|
/* Temporarily increase the company's money, to be sure that
|
|
|
* removing his/her property doesn't fail because of lack of money.
|
|
|
* Not too drastically though, because it could overflow */
|
|
|
if (new_owner == INVALID_OWNER) {
|
|
|
Company::Get(old_owner)->money = UINT64_MAX >> 2; // jackpot ;p
|
|
|
}
|
|
|
|
|
|
if (new_owner == INVALID_OWNER) {
|
|
|
Subsidy *s;
|
|
|
FOR_ALL_SUBSIDIES(s) {
|
|
|
if (s->IsAwarded() && Station::Get(s->dst)->owner == old_owner) {
|
|
|
s->cargo_type = CT_INVALID;
|
|
|
Subsidy *s;
|
|
|
FOR_ALL_SUBSIDIES(s) {
|
|
|
if (s->awarded == old_owner) {
|
|
|
if (new_owner == INVALID_OWNER) {
|
|
|
DeleteSubsidy(s);
|
|
|
} else {
|
|
|
s->awarded = new_owner;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Take care of rating in towns */
|
|
|
FOR_ALL_TOWNS(t) {
|
|
|
/* If a company takes over, give the ratings to that company. */
|
|
|
if (new_owner != INVALID_OWNER) {
|
|
|
if (HasBit(t->have_ratings, old_owner)) {
|
|
|
if (HasBit(t->have_ratings, new_owner)) {
|
|
|
/* use max of the two ratings. */
|
|
|
t->ratings[new_owner] = max(t->ratings[new_owner], t->ratings[old_owner]);
|
|
|
} else {
|
|
|
SetBit(t->have_ratings, new_owner);
|
|
|
t->ratings[new_owner] = t->ratings[old_owner];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Reset the ratings for the old owner */
|
|
|
t->ratings[old_owner] = RATING_INITIAL;
|
|
|
ClrBit(t->have_ratings, old_owner);
|
|
|
}
|
|
|
|
|
|
{
|
|
|
FreeUnitIDGenerator unitidgen[] = {
|
|
|
FreeUnitIDGenerator(VEH_TRAIN, new_owner), FreeUnitIDGenerator(VEH_ROAD, new_owner),
|
|
|
FreeUnitIDGenerator(VEH_SHIP, new_owner), FreeUnitIDGenerator(VEH_AIRCRAFT, new_owner)
|
|
|
};
|
|
|
|
|
|
Vehicle *v;
|
|
|
FOR_ALL_VEHICLES(v) {
|
|
|
if (v->owner == old_owner && IsCompanyBuildableVehicleType(v->type)) {
|
|
|
if (new_owner == INVALID_OWNER) {
|
|
|
if (v->Previous() == NULL) delete v;
|
|
|
} else {
|
|
|
v->owner = new_owner;
|
|
|
v->colourmap = PAL_NONE;
|
|
|
if (v->IsEngineCountable()) Company::Get(new_owner)->num_engines[v->engine_type]++;
|
|
|
if (v->IsPrimaryVehicle()) v->unitnumber = unitidgen[v->type].NextID();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Change ownership of tiles */
|
|
|
{
|
|
|
TileIndex tile = 0;
|
|
|
do {
|
|
|
ChangeTileOwner(tile, old_owner, new_owner);
|
|
|
} while (++tile != MapSize());
|
|
|
|
|
|
if (new_owner != INVALID_OWNER) {
|
|
|
/* Update all signals because there can be new segment that was owned by two companies
|
|
|
* and signals were not propagated
|
|
|
* Similiar with crossings - it is needed to bar crossings that weren't before
|
|
|
* because of different owner of crossing and approaching train */
|
|
|
tile = 0;
|
|
|
|
|
|
do {
|
|
|
if (IsTileType(tile, MP_RAILWAY) && IsTileOwner(tile, new_owner) && HasSignals(tile)) {
|
|
|
TrackBits tracks = GetTrackBits(tile);
|
|
|
do { // there may be two tracks with signals for TRACK_BIT_HORZ and TRACK_BIT_VERT
|
|
|
Track track = RemoveFirstTrack(&tracks);
|
|
|
if (HasSignalOnTrack(tile, track)) AddTrackToSignalBuffer(tile, track, new_owner);
|
|
|
} while (tracks != TRACK_BIT_NONE);
|
|
|
} else if (IsLevelCrossingTile(tile) && IsTileOwner(tile, new_owner)) {
|
|
|
UpdateLevelCrossing(tile);
|
|
|
}
|
|
|
} while (++tile != MapSize());
|
|
|
}
|
|
|
|
|
|
/* update signals in buffer */
|
|
|
UpdateSignalsInBuffer();
|
|
|
}
|
|
|
|
|
|
/* convert owner of stations (including deleted ones, but excluding buoys) */
|
|
|
Station *st;
|
|
|
FOR_ALL_STATIONS(st) {
|
|
|
if (st->owner == old_owner) {
|
|
|
/* if a company goes bankrupt, set owner to OWNER_NONE so the sign doesn't disappear immediately
|
|
|
* also, drawing station window would cause reading invalid company's colour */
|
|
|
st->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* do the same for waypoints (we need to do this here so deleted waypoints are converted too) */
|
|
|
Waypoint *wp;
|
|
|
FOR_ALL_WAYPOINTS(wp) {
|
|
|
if (wp->owner == old_owner) {
|
|
|
wp->owner = new_owner == INVALID_OWNER ? OWNER_NONE : new_owner;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* In all cases clear replace engine rules.
|
|
|
* Even if it was copied, it could interfere with new owner's rules */
|
|
@@ -823,328 +825,321 @@ Money GetPriceByIndex(uint8 index)
|
|
|
Money GetTransportedGoodsIncome(uint num_pieces, uint dist, byte transit_days, CargoID cargo_type)
|
|
|
{
|
|
|
const CargoSpec *cs = CargoSpec::Get(cargo_type);
|
|
|
|
|
|
/* Use callback to calculate cargo profit, if available */
|
|
|
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;
|
|
|
|
|
|
/* "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;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* zero the distance (thus income) if it's the bank and very short transport. */
|
|
|
if (_settings_game.game_creation.landscape == LT_TEMPERATE && cs->label == 'VALU' && dist < 10) return 0;
|
|
|
|
|
|
|
|
|
static const int MIN_TIME_FACTOR = 31;
|
|
|
static const int MAX_TIME_FACTOR = 255;
|
|
|
|
|
|
const int days1 = cs->transit_days[0];
|
|
|
const int days2 = cs->transit_days[1];
|
|
|
const int days_over_days1 = max( transit_days - days1, 0);
|
|
|
const int days_over_days2 = max(days_over_days1 - days2, 0);
|
|
|
|
|
|
/*
|
|
|
* The time factor is calculated based on the time it took
|
|
|
* (transit_days) compared two cargo-depending values. The
|
|
|
* range is divided into three parts:
|
|
|
*
|
|
|
* - constant for fast transits
|
|
|
* - linear decreasing with time with a slope of -1 for medium transports
|
|
|
* - linear decreasing with time with a slope of -2 for slow transports
|
|
|
*
|
|
|
*/
|
|
|
const int time_factor = max(MAX_TIME_FACTOR - days_over_days1 - days_over_days2, MIN_TIME_FACTOR);
|
|
|
|
|
|
return BigMulS(dist * time_factor * num_pieces, _cargo_payment_rates[cargo_type], 21);
|
|
|
}
|
|
|
|
|
|
/** The industries we've currently brought cargo to. */
|
|
|
static SmallIndustryList _cargo_delivery_destinations;
|
|
|
|
|
|
/**
|
|
|
* Transfer goods from station to industry.
|
|
|
* All cargo is delivered to the nearest (Manhattan) industry to the station sign, which is inside the acceptance rectangle and actually accepts the cargo.
|
|
|
* @param st The station that accepted the cargo
|
|
|
* @param cargo_type Type of cargo delivered
|
|
|
* @param nun_pieces Amount of cargo delivered
|
|
|
*/
|
|
|
static void DeliverGoodsToIndustry(const Station *st, CargoID cargo_type, int num_pieces)
|
|
|
{
|
|
|
/* Find the nearest industrytile to the station sign inside the catchment area, whose industry accepts the cargo.
|
|
|
* This fails in three cases:
|
|
|
* 1) The station accepts the cargo because there are enough houses around it accepting the cargo.
|
|
|
* 2) The industries in the catchment area temporarily reject the cargo, and the daily station loop has not yet updated station acceptance.
|
|
|
* 3) The results of callbacks CBID_INDUSTRY_REFUSE_CARGO and CBID_INDTILE_CARGO_ACCEPTANCE are inconsistent. (documented behaviour)
|
|
|
*/
|
|
|
|
|
|
for (uint i = 0; i < st->industries_near.Length(); i++) {
|
|
|
Industry *ind = st->industries_near[i];
|
|
|
const IndustrySpec *indspec = GetIndustrySpec(ind->type);
|
|
|
|
|
|
uint cargo_index;
|
|
|
for (cargo_index = 0; cargo_index < lengthof(ind->accepts_cargo); cargo_index++) {
|
|
|
if (cargo_type == ind->accepts_cargo[cargo_index]) break;
|
|
|
}
|
|
|
/* Check if matching cargo has been found */
|
|
|
if (cargo_index >= lengthof(ind->accepts_cargo)) continue;
|
|
|
|
|
|
/* Check if industry temporarily refuses acceptance */
|
|
|
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;
|
|
|
}
|
|
|
|
|
|
/* Insert the industry into _cargo_delivery_destinations, if not yet contained */
|
|
|
_cargo_delivery_destinations.Include(ind);
|
|
|
|
|
|
ind->incoming_cargo_waiting[cargo_index] = min(num_pieces + ind->incoming_cargo_waiting[cargo_index], 0xFFFF);
|
|
|
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Delivers goods to industries/towns and calculates the payment
|
|
|
* @param num_pieces amount of cargo delivered
|
|
|
* @param source Originstation of the cargo
|
|
|
* @param dest Station the cargo has been unloaded
|
|
|
* @param source_tile The origin of the cargo for distance calculation
|
|
|
* @param days_in_transit Travel time
|
|
|
* @param company The company delivering the cargo
|
|
|
* The cargo is just added to the stockpile of the industry. It is due to the caller to trigger the industry's production machinery
|
|
|
* @param src_type Type of source of cargo (industry, town, headquarters)
|
|
|
* @param src Index of source of cargo
|
|
|
* @return Revenue for delivering cargo
|
|
|
* @note The cargo is just added to the stockpile of the industry. It is due to the caller to trigger the industry's production machinery
|
|
|
*/
|
|
|
static Money DeliverGoods(int num_pieces, CargoID cargo_type, StationID source, StationID dest, TileIndex source_tile, byte days_in_transit, Company *company)
|
|
|
static Money DeliverGoods(int num_pieces, CargoID cargo_type, StationID dest, TileIndex source_tile, byte days_in_transit, Company *company, SourceType src_type, SourceID src)
|
|
|
{
|
|
|
bool subsidised = false;
|
|
|
|
|
|
assert(num_pieces > 0);
|
|
|
|
|
|
/* Update company statistics */
|
|
|
company->cur_economy.delivered_cargo += num_pieces;
|
|
|
SetBit(company->cargo_types, cargo_type);
|
|
|
|
|
|
const Station *s_to = Station::Get(dest);
|
|
|
|
|
|
if (source != INVALID_STATION) {
|
|
|
const Station *s_from = Station::Get(source);
|
|
|
|
|
|
/* Check if a subsidy applies. */
|
|
|
subsidised = CheckSubsidised(s_from, s_to, cargo_type, company->index);
|
|
|
}
|
|
|
const Station *st = Station::Get(dest);
|
|
|
|
|
|
/* Increase town's counter for some special goods types */
|
|
|
const CargoSpec *cs = CargoSpec::Get(cargo_type);
|
|
|
if (cs->town_effect == TE_FOOD) s_to->town->new_act_food += num_pieces;
|
|
|
if (cs->town_effect == TE_WATER) s_to->town->new_act_water += num_pieces;
|
|
|
if (cs->town_effect == TE_FOOD) st->town->new_act_food += num_pieces;
|
|
|
if (cs->town_effect == TE_WATER) st->town->new_act_water += num_pieces;
|
|
|
|
|
|
/* Give the goods to the industry. */
|
|
|
DeliverGoodsToIndustry(s_to, cargo_type, num_pieces);
|
|
|
DeliverGoodsToIndustry(st, cargo_type, num_pieces);
|
|
|
|
|
|
/* Determine profit */
|
|
|
Money profit = GetTransportedGoodsIncome(num_pieces, DistanceManhattan(source_tile, s_to->xy), days_in_transit, cargo_type);
|
|
|
Money profit = GetTransportedGoodsIncome(num_pieces, DistanceManhattan(source_tile, st->xy), days_in_transit, cargo_type);
|
|
|
|
|
|
/* Modify profit if a subsidy is in effect */
|
|
|
if (subsidised) {
|
|
|
if (CheckSubsidised(cargo_type, company->index, src_type, src, st)) {
|
|
|
switch (_settings_game.difficulty.subsidy_multiplier) {
|
|
|
case 0: profit += profit >> 1; break;
|
|
|
case 1: profit *= 2; break;
|
|
|
case 2: profit *= 3; break;
|
|
|
default: profit *= 4; break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return profit;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Inform the industry about just delivered cargo
|
|
|
* DeliverGoodsToIndustry() silently incremented incoming_cargo_waiting, now it is time to do something with the new cargo.
|
|
|
* @param i The industry to process
|
|
|
*/
|
|
|
static void TriggerIndustryProduction(Industry *i)
|
|
|
{
|
|
|
const IndustrySpec *indspec = GetIndustrySpec(i->type);
|
|
|
uint16 callback = indspec->callback_flags;
|
|
|
|
|
|
i->was_cargo_delivered = true;
|
|
|
i->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)) {
|
|
|
IndustryProductionCallback(i, 0);
|
|
|
} else {
|
|
|
InvalidateWindow(WC_INDUSTRY_VIEW, i->index);
|
|
|
}
|
|
|
} else {
|
|
|
for (uint cargo_index = 0; cargo_index < lengthof(i->incoming_cargo_waiting); cargo_index++) {
|
|
|
uint cargo_waiting = i->incoming_cargo_waiting[cargo_index];
|
|
|
if (cargo_waiting == 0) continue;
|
|
|
|
|
|
i->produced_cargo_waiting[0] = min(i->produced_cargo_waiting[0] + (cargo_waiting * indspec->input_cargo_multiplier[cargo_index][0] / 256), 0xFFFF);
|
|
|
i->produced_cargo_waiting[1] = min(i->produced_cargo_waiting[1] + (cargo_waiting * indspec->input_cargo_multiplier[cargo_index][1] / 256), 0xFFFF);
|
|
|
|
|
|
i->incoming_cargo_waiting[cargo_index] = 0;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
TriggerIndustry(i, INDUSTRY_TRIGGER_RECEIVED_CARGO);
|
|
|
StartStopIndustryTileAnimation(i, IAT_INDUSTRY_RECEIVED_CARGO);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Makes us a new cargo payment helper.
|
|
|
* @param front The front of the train
|
|
|
* @param destinations List to add the destinations of 'our' cargo to
|
|
|
*/
|
|
|
CargoPayment::CargoPayment(Vehicle *front) :
|
|
|
front(front),
|
|
|
current_station(front->last_station_visited)
|
|
|
{
|
|
|
}
|
|
|
|
|
|
CargoPayment::~CargoPayment()
|
|
|
{
|
|
|
if (this->CleaningPool()) return;
|
|
|
|
|
|
this->front->cargo_payment = NULL;
|
|
|
|
|
|
if (this->visual_profit == 0) return;
|
|
|
|
|
|
CompanyID old_company = _current_company;
|
|
|
_current_company = this->front->owner;
|
|
|
|
|
|
SubtractMoneyFromCompany(CommandCost(this->front->GetExpenseType(true), -this->route_profit));
|
|
|
this->front->profit_this_year += this->visual_profit << 8;
|
|
|
|
|
|
if (this->route_profit != 0) {
|
|
|
if (IsLocalCompany() && !PlayVehicleSound(this->front, VSE_LOAD_UNLOAD)) {
|
|
|
SndPlayVehicleFx(SND_14_CASHTILL, this->front);
|
|
|
}
|
|
|
|
|
|
ShowCostOrIncomeAnimation(this->front->x_pos, this->front->y_pos, this->front->z_pos, -this->visual_profit);
|
|
|
} else {
|
|
|
ShowFeederIncomeAnimation(this->front->x_pos, this->front->y_pos, this->front->z_pos, this->visual_profit);
|
|
|
}
|
|
|
|
|
|
_current_company = old_company;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Handle payment for final delivery of the given cargo packet.
|
|
|
* @param cp The cargo packet to pay for.
|
|
|
* @param count The number of packets to pay for.
|
|
|
*/
|
|
|
void CargoPayment::PayFinalDelivery(CargoPacket *cp, uint count)
|
|
|
{
|
|
|
if (this->owner == NULL) {
|
|
|
this->owner = Company::Get(this->front->owner);
|
|
|
}
|
|
|
|
|
|
/* Handle end of route payment */
|
|
|
Money profit = DeliverGoods(count, this->ct, cp->source, this->current_station, cp->source_xy, cp->days_in_transit, this->owner);
|
|
|
Money profit = DeliverGoods(count, this->ct, this->current_station, cp->source_xy, cp->days_in_transit, this->owner, cp->source_type, cp->source_id);
|
|
|
this->route_profit += profit;
|
|
|
|
|
|
/* The vehicle's profit is whatever route profit there is minus feeder shares. */
|
|
|
this->visual_profit += profit - cp->feeder_share;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Handle payment for transfer of the given cargo packet.
|
|
|
* @param cp The cargo packet to pay for.
|
|
|
* @param count The number of packets to pay for.
|
|
|
*/
|
|
|
void CargoPayment::PayTransfer(CargoPacket *cp, uint count)
|
|
|
{
|
|
|
Money profit = GetTransportedGoodsIncome(
|
|
|
count,
|
|
|
/* pay transfer vehicle for only the part of transfer it has done: ie. cargo_loaded_at_xy to here */
|
|
|
DistanceManhattan(cp->loaded_at_xy, Station::Get(this->current_station)->xy),
|
|
|
cp->days_in_transit,
|
|
|
this->ct);
|
|
|
|
|
|
this->visual_profit += profit; // accumulate transfer profits for whole vehicle
|
|
|
cp->feeder_share += profit; // account for the (virtual) profit already made for the cargo packet
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Prepare the vehicle to be unloaded.
|
|
|
* @param front_v the vehicle to be unloaded
|
|
|
*/
|
|
|
void PrepareUnload(Vehicle *front_v)
|
|
|
{
|
|
|
/* At this moment loading cannot be finished */
|
|
|
ClrBit(front_v->vehicle_flags, VF_LOADING_FINISHED);
|
|
|
|
|
|
/* Start unloading in at the first possible moment */
|
|
|
front_v->load_unload_time_rem = 1;
|
|
|
|
|
|
if ((front_v->current_order.GetUnloadType() & OUFB_NO_UNLOAD) == 0) {
|
|
|
for (Vehicle *v = front_v; v != NULL; v = v->Next()) {
|
|
|
if (v->cargo_cap > 0 && !v->cargo.Empty()) {
|
|
|
SetBit(v->vehicle_flags, VF_CARGO_UNLOADING);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
assert(front_v->cargo_payment == NULL);
|
|
|
front_v->cargo_payment = new CargoPayment(front_v);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* Loads/unload the vehicle if possible.
|
|
|
* @param v the vehicle to be (un)loaded
|
|
|
* @param cargo_left the amount of each cargo type that is
|
|
|
* virtually left on the platform to be
|
|
|
* picked up by another vehicle when all
|
|
|
* previous vehicles have loaded.
|
|
|
*/
|
|
|
static void LoadUnloadVehicle(Vehicle *v, int *cargo_left)
|
|
|
{
|
|
|
assert(v->current_order.IsType(OT_LOADING));
|
|
|
assert(v->load_unload_time_rem != 0);
|
|
|
|
|
|
/* We have not waited enough time till the next round of loading/unloading */
|
|
|
if (--v->load_unload_time_rem != 0) {
|
|
|
if (_settings_game.order.improved_load && (v->current_order.GetLoadType() & OLFB_FULL_LOAD)) {
|
|
|
/* 'Reserve' this cargo for this vehicle, because we were first. */
|
|
|
for (; v != NULL; v = v->Next()) {
|
|
|
int cap_left = v->cargo_cap - v->cargo.Count();
|
|
|
if (cap_left > 0) cargo_left[v->cargo_type] -= cap_left;
|
|
|
}
|
|
|
}
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
StationID last_visited = v->last_station_visited;
|
|
|
Station *st = Station::Get(last_visited);
|
|
|
|
|
|
if (v->type == VEH_TRAIN && (!IsTileType(v->tile, MP_STATION) || GetStationIndex(v->tile) != st->index)) {
|
|
|
/* 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);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
int unloading_time = 0;
|
|
|
Vehicle *u = v;
|
|
|
int result = 0;
|
|
|
|
|
|
bool completely_emptied = true;
|
|
|
bool anything_unloaded = false;
|
|
|
bool anything_loaded = false;
|
|
|
uint32 cargo_not_full = 0;
|
|
|
uint32 cargo_full = 0;
|
|
|
|
|
|
v->cur_speed = 0;
|
|
|
|
|
|
CargoPayment *payment = v->cargo_payment;
|