cargoaction.h

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/>.
 */
 
#ifndef CARGOACTION_H
#define CARGOACTION_H
 
#include "cargopacket.h"
 
template<class Tsource>
class CargoRemoval {
protected:
  Tsource *source; 
  uint max_move;   
  uint Preprocess(CargoPacket *cp);
  bool Postprocess(CargoPacket *cp, uint remove);
public:
  CargoRemoval(Tsource *source, uint max_move) : source(source), max_move(max_move) {}
 
  uint MaxMove() { return this->max_move; }
 
  bool operator()(CargoPacket *cp);
};
 
class CargoDelivery : public CargoRemoval<VehicleCargoList> {
protected:
  TileIndex current_tile; 
  CargoPayment *payment; 
public:
  CargoDelivery(VehicleCargoList *source, uint max_move, CargoPayment *payment, TileIndex current_tile) :
      CargoRemoval<VehicleCargoList>(source, max_move), current_tile(current_tile), payment(payment) {}
  bool operator()(CargoPacket *cp);
};
 
template<class Tsource, class Tdest>
class CargoMovement {
protected:
  Tsource *source;    
  Tdest *destination; 
  uint max_move;      
  CargoPacket *Preprocess(CargoPacket *cp);
public:
  CargoMovement(Tsource *source, Tdest *destination, uint max_move) : source(source), destination(destination), max_move(max_move) {}
 
  uint MaxMove() { return this->max_move; }
};
 
class CargoTransfer : public CargoMovement<VehicleCargoList, StationCargoList> {
protected:
  TileIndex current_tile; 
public:
  CargoTransfer(VehicleCargoList *source, StationCargoList *destination, uint max_move, TileIndex current_tile) :
      CargoMovement<VehicleCargoList, StationCargoList>(source, destination, max_move), current_tile(current_tile) {}
  bool operator()(CargoPacket *cp);
};
 
class CargoLoad : public CargoMovement<StationCargoList, VehicleCargoList> {
protected:
  TileIndex current_tile; 
public:
  CargoLoad(StationCargoList *source, VehicleCargoList *destination, uint max_move, TileIndex current_tile) :
      CargoMovement<StationCargoList, VehicleCargoList>(source, destination, max_move), current_tile(current_tile) {}
  bool operator()(CargoPacket *cp);
};
 
class CargoReservation : public CargoLoad {
public:
  CargoReservation(StationCargoList *source, VehicleCargoList *destination, uint max_move, TileIndex current_tile) :
      CargoLoad(source, destination, max_move, current_tile) {}
  bool operator()(CargoPacket *cp);
};
 
class CargoReturn : public CargoMovement<VehicleCargoList, StationCargoList> {
protected:
  TileIndex current_tile; 
  StationID next;
public:
  CargoReturn(VehicleCargoList *source, StationCargoList *destination, uint max_move, StationID next, TileIndex current_tile) :
      CargoMovement<VehicleCargoList, StationCargoList>(source, destination, max_move), current_tile(current_tile), next(next) {}
  bool operator()(CargoPacket *cp);
};
 
class CargoShift : public CargoMovement<VehicleCargoList, VehicleCargoList> {
public:
  CargoShift(VehicleCargoList *source, VehicleCargoList *destination, uint max_move) :
      CargoMovement<VehicleCargoList, VehicleCargoList>(source, destination, max_move) {}
  bool operator()(CargoPacket *cp);
};
 
template<class Tlist>
class CargoReroute : public CargoMovement<Tlist, Tlist> {
protected:
  StationID avoid;
  StationID avoid2;
  const GoodsEntry *ge;
public:
  CargoReroute(Tlist *source, Tlist *dest, uint max_move, StationID avoid, StationID avoid2, const GoodsEntry *ge) :
      CargoMovement<Tlist, Tlist>(source, dest, max_move), avoid(avoid), avoid2(avoid2), ge(ge) {}
};
 
class StationCargoReroute : public CargoReroute<StationCargoList> {
public:
  StationCargoReroute(StationCargoList *source, StationCargoList *dest, uint max_move, StationID avoid, StationID avoid2, const GoodsEntry *ge) :
        CargoReroute<StationCargoList>(source, dest, max_move, avoid, avoid2, ge) {}
  bool operator()(CargoPacket *cp);
};
 
class VehicleCargoReroute : public CargoReroute<VehicleCargoList> {
public:
  VehicleCargoReroute(VehicleCargoList *source, VehicleCargoList *dest, uint max_move, StationID avoid, StationID avoid2, const GoodsEntry *ge) :
      CargoReroute<VehicleCargoList>(source, dest, max_move, avoid, avoid2, ge)
  {
    assert(this->max_move <= source->ActionCount(VehicleCargoList::MTA_TRANSFER));
  }
  bool operator()(CargoPacket *cp);
};
 
#endif /* CARGOACTION_H */