cargoaction.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "stdafx.h"
#include "economy_base.h"
#include "cargoaction.h"
#include "station_base.h"
 
#include "safeguards.h"
 
template<class Tsource, class Tdest>
CargoPacket *CargoMovement<Tsource, Tdest>::Preprocess(CargoPacket *cp)
{
  if (this->max_move < cp->Count()) {
    cp = cp->Split(this->max_move);
    this->max_move = 0;
  } else {
    this->max_move -= cp->Count();
  }
  return cp;
}
 
template<class Tsource>
uint CargoRemoval<Tsource>::Preprocess(CargoPacket *cp)
{
  if (this->max_move >= cp->Count()) {
    this->max_move -= cp->Count();
    return cp->Count();
  } else {
    uint ret = this->max_move;
    this->max_move = 0;
    return ret;
  }
}
 
template<class Tsource>
bool CargoRemoval<Tsource>::Postprocess(CargoPacket *cp, uint remove)
{
  if (remove == cp->Count()) {
    delete cp;
    return true;
  } else {
    cp->Reduce(remove);
    return false;
  }
}
 
template<>
bool CargoRemoval<StationCargoList>::operator()(CargoPacket *cp)
{
  uint remove = this->Preprocess(cp);
  this->source->RemoveFromCache(cp, remove);
  return this->Postprocess(cp, remove);
}
 
template<>
bool CargoRemoval<VehicleCargoList>::operator()(CargoPacket *cp)
{
  uint remove = this->Preprocess(cp);
  this->source->RemoveFromMeta(cp, VehicleCargoList::MTA_KEEP, remove);
  return this->Postprocess(cp, remove);
}
 
bool CargoDelivery::operator()(CargoPacket *cp)
{
  uint remove = this->Preprocess(cp);
  this->source->RemoveFromMeta(cp, VehicleCargoList::MTA_DELIVER, remove);
  this->payment->PayFinalDelivery(this->cargo, cp, remove, this->current_tile);
  return this->Postprocess(cp, remove);
}
 
bool CargoLoad::operator()(CargoPacket *cp)
{
  CargoPacket *cp_new = this->Preprocess(cp);
  if (cp_new == nullptr) return false;
  cp_new->UpdateLoadingTile(this->current_tile);
  this->source->RemoveFromCache(cp_new, cp_new->Count());
  this->destination->Append(cp_new, VehicleCargoList::MTA_KEEP);
  return cp_new == cp;
}
 
bool CargoReservation::operator()(CargoPacket *cp)
{
  CargoPacket *cp_new = this->Preprocess(cp);
  if (cp_new == nullptr) return false;
  cp_new->UpdateLoadingTile(this->current_tile);
  this->source->reserved_count += cp_new->Count();
  this->source->RemoveFromCache(cp_new, cp_new->Count());
  this->destination->Append(cp_new, VehicleCargoList::MTA_LOAD);
  return cp_new == cp;
}
 
bool CargoReturn::operator()(CargoPacket *cp)
{
  CargoPacket *cp_new = this->Preprocess(cp);
  if (cp_new == nullptr) cp_new = cp;
  assert(cp_new->Count() <= this->destination->reserved_count);
  cp_new->UpdateUnloadingTile(this->current_tile);
  this->source->RemoveFromMeta(cp_new, VehicleCargoList::MTA_LOAD, cp_new->Count());
  this->destination->reserved_count -= cp_new->Count();
  this->destination->Append(cp_new, this->next);
  return cp_new == cp;
}
 
bool CargoTransfer::operator()(CargoPacket *cp)
{
  CargoPacket *cp_new = this->Preprocess(cp);
  if (cp_new == nullptr) return false;
  cp_new->UpdateUnloadingTile(this->current_tile);
  this->source->RemoveFromMeta(cp_new, VehicleCargoList::MTA_TRANSFER, cp_new->Count());
  /* No transfer credits here as they were already granted during Stage(). */
  this->destination->Append(cp_new, cp_new->GetNextHop());
  return cp_new == cp;
}
 
bool CargoShift::operator()(CargoPacket *cp)
{
  CargoPacket *cp_new = this->Preprocess(cp);
  if (cp_new == nullptr) cp_new = cp;
  this->source->RemoveFromMeta(cp_new, VehicleCargoList::MTA_KEEP, cp_new->Count());
  this->destination->Append(cp_new, VehicleCargoList::MTA_KEEP);
  return cp_new == cp;
}
 
bool StationCargoReroute::operator()(CargoPacket *cp)
{
  CargoPacket *cp_new = this->Preprocess(cp);
  if (cp_new == nullptr) cp_new = cp;
  StationID next = this->ge->GetVia(cp_new->GetFirstStation(), this->avoid, this->avoid2);
  assert(next != this->avoid && next != this->avoid2);
  if (this->source != this->destination) {
    this->source->RemoveFromCache(cp_new, cp_new->Count());
    this->destination->AddToCache(cp_new);
  }
 
  /* Legal, as insert doesn't invalidate iterators in the MultiMap, however
   * this might insert the packet between range.first and range.second (which might be end())
   * This is why we check for GetKey above to avoid infinite loops. */
  this->destination->packets.Insert(next, cp_new);
  return cp_new == cp;
}
 
bool VehicleCargoReroute::operator()(CargoPacket *cp)
{
  CargoPacket *cp_new = this->Preprocess(cp);
  if (cp_new == nullptr) cp_new = cp;
  if (cp_new->GetNextHop() == this->avoid || cp_new->GetNextHop() == this->avoid2) {
    cp->SetNextHop(this->ge->GetVia(cp_new->GetFirstStation(), this->avoid, this->avoid2));
  }
  if (this->source != this->destination) {
    this->source->RemoveFromMeta(cp_new, VehicleCargoList::MTA_TRANSFER, cp_new->Count());
    this->destination->AddToMeta(cp_new, VehicleCargoList::MTA_TRANSFER);
  }
 
  /* Legal, as front pushing doesn't invalidate iterators in std::list. */
  this->destination->packets.push_front(cp_new);
  return cp_new == cp;
}
 
template uint CargoRemoval<VehicleCargoList>::Preprocess(CargoPacket *cp);
template uint CargoRemoval<StationCargoList>::Preprocess(CargoPacket *cp);
template bool CargoRemoval<VehicleCargoList>::Postprocess(CargoPacket *cp, uint remove);
template bool CargoRemoval<StationCargoList>::Postprocess(CargoPacket *cp, uint remove);