src/cargoaction.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file cargoaction.h Actions to be applied to cargo packets. */
   9
  10 #ifndef CARGOACTION_H
  11 #define CARGOACTION_H
  12
  13 #include "cargopacket.h"
  14
  15 /**
  16  * Abstract action of removing cargo from a vehicle or a station.
  17  * @tparam Tsource CargoList subclass to remove cargo from.
  18  */
  19 template<class Tsource>
  20 class CargoRemoval {
  21 protected:
  22         Tsource *source; ///< Source of the cargo.
  23         uint max_move;   ///< Maximum amount of cargo to be removed with this action.
  24         uint Preprocess(CargoPacket *cp);
  25         bool Postprocess(CargoPacket *cp, uint remove);
  26 public:
  27         CargoRemoval(Tsource *source, uint max_move) : source(source), max_move(max_move) {}
  28
  29         /**
  30          * Returns how much more cargo can be removed with this action.
  31          * @return Amount of cargo this action can still remove.
  32          */
  33         uint MaxMove() { return this->max_move; }
  34
  35         bool operator()(CargoPacket *cp);
  36 };
  37
  38 /** Action of final delivery of cargo. */
  39 class CargoDelivery : public CargoRemoval<VehicleCargoList> {
  40 protected:
  41         TileIndex current_tile; ///< Current tile cargo delivery is happening.
  42         CargoPayment *payment; ///< Payment object where payments will be registered.
  43         CargoID cargo; ///< The cargo type of the cargo.
  44 public:
  45         CargoDelivery(VehicleCargoList *source, uint max_move, CargoID cargo, CargoPayment *payment, TileIndex current_tile) :
  46                         CargoRemoval<VehicleCargoList>(source, max_move), current_tile(current_tile), payment(payment), cargo(cargo) {}
  47         bool operator()(CargoPacket *cp);
  48 };
  49
  50 /**
  51  * Abstract action for moving cargo from one list to another.
  52  * @tparam Tsource CargoList subclass to remove cargo from.
  53  * @tparam Tdest CargoList subclass to add cargo to.
  54  */
  55 template<class Tsource, class Tdest>
  56 class CargoMovement {
  57 protected:
  58         Tsource *source;    ///< Source of the cargo.
  59         Tdest *destination; ///< Destination for the cargo.
  60         uint max_move;      ///< Maximum amount of cargo to be moved with this action.
  61         CargoPacket *Preprocess(CargoPacket *cp);
  62 public:
  63         CargoMovement(Tsource *source, Tdest *destination, uint max_move) : source(source), destination(destination), max_move(max_move) {}
  64
  65         /**
  66          * Returns how much more cargo can be moved with this action.
  67          * @return Amount of cargo this action can still move.
  68          */
  69         uint MaxMove() { return this->max_move; }
  70 };
  71
  72 /** Action of transferring cargo from a vehicle to a station. */
  73 class CargoTransfer : public CargoMovement<VehicleCargoList, StationCargoList> {
  74 protected:
  75         TileIndex current_tile; ///< Current tile cargo unloading is happening.
  76 public:
  77         CargoTransfer(VehicleCargoList *source, StationCargoList *destination, uint max_move, TileIndex current_tile) :
  78                         CargoMovement<VehicleCargoList, StationCargoList>(source, destination, max_move), current_tile(current_tile) {}
  79         bool operator()(CargoPacket *cp);
  80 };
  81
  82 /** Action of loading cargo from a station onto a vehicle. */
  83 class CargoLoad : public CargoMovement<StationCargoList, VehicleCargoList> {
  84 protected:
  85         TileIndex current_tile; ///< Current tile cargo loading is happening.
  86 public:
  87         CargoLoad(StationCargoList *source, VehicleCargoList *destination, uint max_move, TileIndex current_tile) :
  88                         CargoMovement<StationCargoList, VehicleCargoList>(source, destination, max_move), current_tile(current_tile) {}
  89         bool operator()(CargoPacket *cp);
  90 };
  91
  92 /** Action of reserving cargo from a station to be loaded onto a vehicle. */
  93 class CargoReservation : public CargoLoad {
  94 public:
  95         CargoReservation(StationCargoList *source, VehicleCargoList *destination, uint max_move, TileIndex current_tile) :
  96                         CargoLoad(source, destination, max_move, current_tile) {}
  97         bool operator()(CargoPacket *cp);
  98 };
  99
 100 /** Action of returning previously reserved cargo from the vehicle to the station. */
 101 class CargoReturn : public CargoMovement<VehicleCargoList, StationCargoList> {
 102 protected:
 103         TileIndex current_tile; ///< Current tile cargo unloading is happening.
 104         StationID next;
 105 public:
 106         CargoReturn(VehicleCargoList *source, StationCargoList *destination, uint max_move, StationID next, TileIndex current_tile) :
 107                         CargoMovement<VehicleCargoList, StationCargoList>(source, destination, max_move), current_tile(current_tile), next(next) {}
 108         bool operator()(CargoPacket *cp);
 109 };
 110
 111 /** Action of shifting cargo from one vehicle to another. */
 112 class CargoShift : public CargoMovement<VehicleCargoList, VehicleCargoList> {
 113 public:
 114         CargoShift(VehicleCargoList *source, VehicleCargoList *destination, uint max_move) :
 115                         CargoMovement<VehicleCargoList, VehicleCargoList>(source, destination, max_move) {}
 116         bool operator()(CargoPacket *cp);
 117 };
 118
 119 /** Action of rerouting cargo between different cargo lists and/or next hops. */
 120 template<class Tlist>
 121 class CargoReroute : public CargoMovement<Tlist, Tlist> {
 122 protected:
 123         StationID avoid;
 124         StationID avoid2;
 125         const GoodsEntry *ge;
 126 public:
 127         CargoReroute(Tlist *source, Tlist *dest, uint max_move, StationID avoid, StationID avoid2, const GoodsEntry *ge) :
 128                         CargoMovement<Tlist, Tlist>(source, dest, max_move), avoid(avoid), avoid2(avoid2), ge(ge) {}
 129 };
 130
 131 /** Action of rerouting cargo in a station. */
 132 class StationCargoReroute : public CargoReroute<StationCargoList> {
 133 public:
 134         StationCargoReroute(StationCargoList *source, StationCargoList *dest, uint max_move, StationID avoid, StationID avoid2, const GoodsEntry *ge) :
 135                                 CargoReroute<StationCargoList>(source, dest, max_move, avoid, avoid2, ge) {}
 136         bool operator()(CargoPacket *cp);
 137 };
 138
 139 /** Action of rerouting cargo staged for transfer in a vehicle. */
 140 class VehicleCargoReroute : public CargoReroute<VehicleCargoList> {
 141 public:
 142         VehicleCargoReroute(VehicleCargoList *source, VehicleCargoList *dest, uint max_move, StationID avoid, StationID avoid2, const GoodsEntry *ge) :
 143                         CargoReroute<VehicleCargoList>(source, dest, max_move, avoid, avoid2, ge)
 144         {
 145                 assert(this->max_move <= source->ActionCount(VehicleCargoList::MTA_TRANSFER));
 146         }
 147         bool operator()(CargoPacket *cp);
 148 };
 149
 150 #endif /* CARGOACTION_H */