src/cargopacket.h

   1 /* $Id: cargopacket.h 26327 2014-02-09 21:10:25Z fonsinchen $ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * 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.
   6  * 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.
   7  * 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/>.
   8  */
   9
  10 /** @file cargopacket.h Base class for cargo packets. */
  11
  12 #ifndef CARGOPACKET_H
  13 #define CARGOPACKET_H
  14
  15 #include "core/pool_type.hpp"
  16 #include "economy_type.h"
  17 #include "station_type.h"
  18 #include "order_type.h"
  19 #include "cargo_type.h"
  20 #include "vehicle_type.h"
  21 #include "core/multimap.hpp"
  22 #include <deque>
  23
  24 /** Unique identifier for a single cargo packet. */
  25 typedef uint32 CargoPacketID;
  26 struct CargoPacket;
  27
  28 /** Type of the pool for cargo packets for a little over 16 million packets. */
  29 typedef Pool<CargoPacket, CargoPacketID, 1024, 0xFFF000, PT_NORMAL, true, false> CargoPacketPool;
  30 /** The actual pool with cargo packets. */
  31 extern CargoPacketPool _cargopacket_pool;
  32
  33 struct GoodsEntry; // forward-declare for Stage() and RerouteStalePackets()
  34
  35 template <class Tinst, class Tcont> class CargoList;
  36 class StationCargoList; // forward-declare, so we can use it in VehicleCargoList.
  37 extern const struct SaveLoad *GetCargoPacketDesc();
  38
  39 typedef uint32 TileOrStationID;
  40
  41 /**
  42  * Container for cargo from the same location and time.
  43  */
  44 struct CargoPacket : CargoPacketPool::PoolItem<&_cargopacket_pool> {
  45 private:
  46         Money feeder_share;         ///< Value of feeder pickup to be paid for on delivery of cargo.
  47         uint16 count;               ///< The amount of cargo in this packet.
  48         byte days_in_transit;       ///< Amount of days this packet has been in transit.
  49         SourceTypeByte source_type; ///< Type of \c source_id.
  50         SourceID source_id;         ///< Index of source, INVALID_SOURCE if unknown/invalid.
  51         StationID source;           ///< The station where the cargo came from first.
  52         TileIndex source_xy;        ///< The origin of the cargo (first station in feeder chain).
  53         union {
  54                 TileOrStationID loaded_at_xy; ///< Location where this cargo has been loaded into the vehicle.
  55                 TileOrStationID next_station; ///< Station where the cargo wants to go next.
  56         };
  57
  58         /** The CargoList caches, thus needs to know about it. */
  59         template <class Tinst, class Tcont> friend class CargoList;
  60         friend class VehicleCargoList;
  61         friend class StationCargoList;
  62         /** We want this to be saved, right? */
  63         friend const struct SaveLoad *GetCargoPacketDesc();
  64 public:
  65         /** Maximum number of items in a single cargo packet. */
  66         static const uint16 MAX_COUNT = UINT16_MAX;
  67
  68         CargoPacket();
  69         CargoPacket(StationID source, TileIndex source_xy, uint16 count, SourceType source_type, SourceID source_id);
  70         CargoPacket(uint16 count, byte days_in_transit, StationID source, TileIndex source_xy, TileIndex loaded_at_xy, Money feeder_share = 0, SourceType source_type = ST_INDUSTRY, SourceID source_id = INVALID_SOURCE);
  71
  72         /** Destroy the packet. */
  73         ~CargoPacket() { }
  74
  75         CargoPacket *Split(uint new_size);
  76         void Merge(CargoPacket *cp);
  77         void Reduce(uint count);
  78
  79         /**
  80          * Sets the tile where the packet was loaded last.
  81          * @param load_place Tile where the packet was loaded last.
  82          */
  83         void SetLoadPlace(TileIndex load_place) { this->loaded_at_xy = load_place; }
  84
  85         /**
  86          * Sets the station where the packet is supposed to go next.
  87          * @param next_station Next station the packet should go to.
  88          */
  89         void SetNextStation(StationID next_station) { this->next_station = next_station; }
  90
  91         /**
  92          * Adds some feeder share to the packet.
  93          * @param new_share Feeder share to be added.
  94          */
  95         void AddFeederShare(Money new_share) { this->feeder_share += new_share; }
  96
  97         /**
  98          * Gets the number of 'items' in this packet.
  99          * @return Item count.
 100          */
 101         inline uint16 Count() const
 102         {
 103                 return this->count;
 104         }
 105
 106         /**
 107          * Gets the amount of money already paid to earlier vehicles in
 108          * the feeder chain.
 109          * @return Feeder share.
 110          */
 111         inline Money FeederShare() const
 112         {
 113                 return this->feeder_share;
 114         }
 115
 116         /**
 117          * Gets part of the amount of money already paid to earlier vehicles in
 118          * the feeder chain.
 119          * @param part Amount of cargo to get the share for.
 120          * @return Feeder share for the given amount of cargo.
 121          */
 122         inline Money FeederShare(uint part) const
 123         {
 124                 return this->feeder_share * part / static_cast<uint>(this->count);
 125         }
 126
 127         /**
 128          * Gets the number of days this cargo has been in transit.
 129          * This number isn't really in days, but in 2.5 days (CARGO_AGING_TICKS = 185 ticks) and
 130          * it is capped at 255.
 131          * @return Length this cargo has been in transit.
 132          */
 133         inline byte DaysInTransit() const
 134         {
 135                 return this->days_in_transit;
 136         }
 137
 138         /**
 139          * Resets the number of days this cargo has been in transit.
 140          */
 141         inline void ResetTransitDays()
 142         {
 143                 this->days_in_transit = 0x00;
 144         }
 145
 146         /**
 147          * Gets the type of the cargo's source. industry, town or head quarter.
 148          * @return Source type.
 149          */
 150         inline SourceType SourceSubsidyType() const
 151         {
 152                 return this->source_type;
 153         }
 154
 155         /**
 156          * Gets the ID of the cargo's source. An IndustryID, TownID or CompanyID.
 157          * @return Source ID.
 158          */
 159         inline SourceID SourceSubsidyID() const
 160         {
 161                 return this->source_id;
 162         }
 163
 164         /**
 165          * Gets the ID of the station where the cargo was loaded for the first time.
 166          * @return StationID.
 167          */
 168         inline StationID SourceStation() const
 169         {
 170                 return this->source;
 171         }
 172
 173         /**
 174          * Gets the coordinates of the cargo's source station.
 175          * @return Source station's coordinates.
 176          */
 177         inline TileIndex SourceStationXY() const
 178         {
 179                 return this->source_xy;
 180         }
 181
 182         /**
 183          * Gets the coordinates of the cargo's last loading station.
 184          * @return Last loading station's coordinates.
 185          */
 186         inline TileIndex LoadedAtXY() const
 187         {
 188                 return this->loaded_at_xy;
 189         }
 190
 191         /**
 192          * Gets the ID of station the cargo wants to go next.
 193          * @return Next station for this packets.
 194          */
 195         inline StationID NextStation() const
 196         {
 197                 return this->next_station;
 198         }
 199
 200         static void InvalidateAllFrom(SourceType src_type, SourceID src);
 201         static void InvalidateAllFrom(StationID sid);
 202         static void AfterLoad();
 203 };
 204
 205 /**
 206  * Iterate over all _valid_ cargo packets from the given start.
 207  * @param var   Variable used as "iterator".
 208  * @param start Cargo packet ID of the first packet to iterate over.
 209  */
 210 #define FOR_ALL_CARGOPACKETS_FROM(var, start) FOR_ALL_ITEMS_FROM(CargoPacket, cargopacket_index, var, start)
 211
 212 /**
 213  * Iterate over all _valid_ cargo packets from the begin of the pool.
 214  * @param var   Variable used as "iterator".
 215  */
 216 #define FOR_ALL_CARGOPACKETS(var) FOR_ALL_CARGOPACKETS_FROM(var, 0)
 217
 218 /**
 219  * Simple collection class for a list of cargo packets.
 220  * @tparam Tinst Actual instantiation of this cargo list.
 221  */
 222 template <class Tinst, class Tcont>
 223 class CargoList {
 224 public:
 225         /** The iterator for our container. */
 226         typedef typename Tcont::iterator Iterator;
 227         /** The reverse iterator for our container. */
 228         typedef typename Tcont::reverse_iterator ReverseIterator;
 229         /** The const iterator for our container. */
 230         typedef typename Tcont::const_iterator ConstIterator;
 231         /** The const reverse iterator for our container. */
 232         typedef typename Tcont::const_reverse_iterator ConstReverseIterator;
 233
 234         /** Kind of actions that could be done with packets on move. */
 235         enum MoveToAction {
 236                 MTA_BEGIN = 0,
 237                 MTA_TRANSFER = 0, ///< Transfer the cargo to the station.
 238                 MTA_DELIVER,      ///< Deliver the cargo to some town or industry.
 239                 MTA_KEEP,         ///< Keep the cargo in the vehicle.
 240                 MTA_LOAD,         ///< Load the cargo from the station.
 241                 MTA_END,
 242                 NUM_MOVE_TO_ACTION = MTA_END
 243         };
 244
 245 protected:
 246         uint count;                 ///< Cache for the number of cargo entities.
 247         uint cargo_days_in_transit; ///< Cache for the sum of number of days in transit of each entity; comparable to man-hours.
 248
 249         Tcont packets;              ///< The cargo packets in this list.
 250
 251         void AddToCache(const CargoPacket *cp);
 252
 253         void RemoveFromCache(const CargoPacket *cp, uint count);
 254
 255         static bool TryMerge(CargoPacket *cp, CargoPacket *icp);
 256
 257 public:
 258         /** Create the cargo list. */
 259         CargoList() {}
 260
 261         ~CargoList();
 262
 263         void OnCleanPool();
 264
 265         /**
 266          * Returns a pointer to the cargo packet list (so you can iterate over it etc).
 267          * @return Pointer to the packet list.
 268          */
 269         inline const Tcont *Packets() const
 270         {
 271                 return &this->packets;
 272         }
 273
 274         /**
 275          * Returns average number of days in transit for a cargo entity.
 276          * @return The before mentioned number.
 277          */
 278         inline uint DaysInTransit() const
 279         {
 280                 return this->count == 0 ? 0 : this->cargo_days_in_transit / this->count;
 281         }
 282
 283         void InvalidateCache();
 284 };
 285
 286 typedef std::deque<CargoPacket *> CargoPacketList;
 287
 288 /**
 289  * CargoList that is used for vehicles.
 290  */
 291 class VehicleCargoList : public CargoList<VehicleCargoList, CargoPacketList> {
 292 protected:
 293         /** The (direct) parent of this class. */
 294         typedef CargoList<VehicleCargoList, CargoPacketList> Parent;
 295
 296         Money feeder_share;                     ///< Cache for the feeder share.
 297         uint action_counts[NUM_MOVE_TO_ACTION]; ///< Counts of cargo to be transfered, delivered, kept and loaded.
 298
 299         template<class Taction>
 300         void ShiftCargo(Taction action);
 301
 302         template<class Taction>
 303         void PopCargo(Taction action);
 304
 305         /**
 306          * Assert that the designation counts add up.
 307          */
 308         inline void AssertCountConsistency() const
 309         {
 310                 assert(this->action_counts[MTA_KEEP] +
 311                                 this->action_counts[MTA_DELIVER] +
 312                                 this->action_counts[MTA_TRANSFER] +
 313                                 this->action_counts[MTA_LOAD] == this->count);
 314         }
 315
 316         void AddToCache(const CargoPacket *cp);
 317         void RemoveFromCache(const CargoPacket *cp, uint count);
 318
 319         void AddToMeta(const CargoPacket *cp, MoveToAction action);
 320         void RemoveFromMeta(const CargoPacket *cp, MoveToAction action, uint count);
 321
 322         static MoveToAction ChooseAction(const CargoPacket *cp, StationID cargo_next,
 323                         StationID current_station, bool accepted, StationIDStack next_station);
 324
 325 public:
 326         /** The station cargo list needs to control the unloading. */
 327         friend class StationCargoList;
 328         /** The super class ought to know what it's doing. */
 329         friend class CargoList<VehicleCargoList, CargoPacketList>;
 330         /** The vehicles have a cargo list (and we want that saved). */
 331         friend const struct SaveLoad *GetVehicleDescription(VehicleType vt);
 332
 333         friend class CargoShift;
 334         friend class CargoTransfer;
 335         friend class CargoDelivery;
 336         template<class Tsource>
 337         friend class CargoRemoval;
 338         friend class CargoReturn;
 339         friend class VehicleCargoReroute;
 340
 341         /**
 342          * Returns source of the first cargo packet in this list.
 343          * @return The before mentioned source.
 344          */
 345         inline StationID Source() const
 346         {
 347                 return this->count == 0 ? INVALID_STATION : this->packets.front()->source;
 348         }
 349
 350         /**
 351          * Returns total sum of the feeder share for all packets.
 352          * @return The before mentioned number.
 353          */
 354         inline Money FeederShare() const
 355         {
 356                 return this->feeder_share;
 357         }
 358
 359         /**
 360          * Returns the amount of cargo designated for a given purpose.
 361          * @param action Action the cargo is designated for.
 362          * @return Amount of cargo designated for the given action.
 363          */
 364         inline uint ActionCount(MoveToAction action) const
 365         {
 366                 return this->action_counts[action];
 367         }
 368
 369         /**
 370          * Returns sum of cargo on board the vehicle (ie not only
 371          * reserved).
 372          * @return Cargo on board the vehicle.
 373          */
 374         inline uint StoredCount() const
 375         {
 376                 return this->count - this->action_counts[MTA_LOAD];
 377         }
 378
 379         /**
 380          * Returns sum of cargo, including reserved cargo.
 381          * @return Sum of cargo.
 382          */
 383         inline uint TotalCount() const
 384         {
 385                 return this->count;
 386         }
 387
 388         /**
 389          * Returns sum of reserved cargo.
 390          * @return Sum of reserved cargo.
 391          */
 392         inline uint ReservedCount() const
 393         {
 394                 return this->action_counts[MTA_LOAD];
 395         }
 396
 397         /**
 398          * Returns sum of cargo to be moved out of the vehicle at the current station.
 399          * @return Cargo to be moved.
 400          */
 401         inline uint UnloadCount() const
 402         {
 403                 return this->action_counts[MTA_TRANSFER] + this->action_counts[MTA_DELIVER];
 404         }
 405
 406         /**
 407          * Returns the sum of cargo to be kept in the vehicle at the current station.
 408          * @return Cargo to be kept or loaded.
 409          */
 410         inline uint RemainingCount() const
 411         {
 412                 return this->action_counts[MTA_KEEP] + this->action_counts[MTA_LOAD];
 413         }
 414
 415         void Append(CargoPacket *cp, MoveToAction action = MTA_KEEP);
 416
 417         void AgeCargo();
 418
 419         void InvalidateCache();
 420
 421         void SetTransferLoadPlace(TileIndex xy);
 422
 423         bool Stage(bool accepted, StationID current_station, StationIDStack next_station, uint8 order_flags, const GoodsEntry *ge, CargoPayment *payment);
 424
 425         /**
 426          * Marks all cargo in the vehicle as to be kept. This is mostly useful for
 427          * loading old savegames. When loading is aborted the reserved cargo has
 428          * to be returned first.
 429          */
 430         inline void KeepAll()
 431         {
 432                 this->action_counts[MTA_DELIVER] = this->action_counts[MTA_TRANSFER] = this->action_counts[MTA_LOAD] = 0;
 433                 this->action_counts[MTA_KEEP] = this->count;
 434         }
 435
 436         /* Methods for moving cargo around. First parameter is always maximum
 437          * amount of cargo to be moved. Second parameter is destination (if
 438          * applicable), return value is amount of cargo actually moved. */
 439
 440         template<MoveToAction Tfrom, MoveToAction Tto>
 441         uint Reassign(uint max_move, TileOrStationID update = INVALID_TILE);
 442         uint Return(uint max_move, StationCargoList *dest, StationID next_station);
 443         uint Unload(uint max_move, StationCargoList *dest, CargoPayment *payment);
 444         uint Shift(uint max_move, VehicleCargoList *dest);
 445         uint Truncate(uint max_move = UINT_MAX);
 446         uint Reroute(uint max_move, VehicleCargoList *dest, StationID avoid, StationID avoid2, const GoodsEntry *ge);
 447
 448         /**
 449          * Are two the two CargoPackets mergeable in the context of
 450          * a list of CargoPackets for a Vehicle?
 451          * @param cp1 First CargoPacket.
 452          * @param cp2 Second CargoPacket.
 453          * @return True if they are mergeable.
 454          */
 455         static bool AreMergable(const CargoPacket *cp1, const CargoPacket *cp2)
 456         {
 457                 return cp1->source_xy    == cp2->source_xy &&
 458                                 cp1->days_in_transit == cp2->days_in_transit &&
 459                                 cp1->source_type     == cp2->source_type &&
 460                                 cp1->source_id       == cp2->source_id &&
 461                                 cp1->loaded_at_xy    == cp2->loaded_at_xy;
 462         }
 463 };
 464
 465 typedef MultiMap<StationID, CargoPacket *, CargoPacketList> StationCargoPacketMap;
 466 typedef std::map<StationID, uint> StationCargoAmountMap;
 467
 468 /**
 469  * CargoList that is used for stations.
 470  */
 471 class StationCargoList : public CargoList<StationCargoList, StationCargoPacketMap> {
 472 protected:
 473         /** The (direct) parent of this class. */
 474         typedef CargoList<StationCargoList, StationCargoPacketMap> Parent;
 475
 476         uint reserved_count; ///< Amount of cargo being reserved for loading.
 477
 478 public:
 479         /** The super class ought to know what it's doing. */
 480         friend class CargoList<StationCargoList, StationCargoPacketMap>;
 481         /** The stations, via GoodsEntry, have a CargoList. */
 482         friend const struct SaveLoad *GetGoodsDesc();
 483
 484         friend class CargoLoad;
 485         friend class CargoTransfer;
 486         template<class Tsource>
 487         friend class CargoRemoval;
 488         friend class CargoReservation;
 489         friend class CargoReturn;
 490         friend class StationCargoReroute;
 491
 492         static void InvalidateAllFrom(SourceType src_type, SourceID src);
 493
 494         template<class Taction>
 495         bool ShiftCargo(Taction &action, StationID next);
 496
 497         template<class Taction>
 498         uint ShiftCargo(Taction action, StationIDStack next, bool include_invalid);
 499
 500         void Append(CargoPacket *cp, StationID next);
 501
 502         /**
 503          * Check for cargo headed for a specific station.
 504          * @param next Station the cargo is headed for.
 505          * @return If there is any cargo for that station.
 506          */
 507         inline bool HasCargoFor(StationIDStack next) const
 508         {
 509                 while (!next.IsEmpty()) {
 510                         if (this->packets.find(next.Pop()) != this->packets.end()) return true;
 511                 }
 512                 /* Packets for INVALID_STTION can go anywhere. */
 513                 return this->packets.find(INVALID_STATION) != this->packets.end();
 514         }
 515
 516         /**
 517          * Returns source of the first cargo packet in this list.
 518          * @return The before mentioned source.
 519          */
 520         inline StationID Source() const
 521         {
 522                 return this->count == 0 ? INVALID_STATION : this->packets.begin()->second.front()->source;
 523         }
 524
 525         /**
 526          * Returns sum of cargo still available for loading at the sation.
 527          * (i.e. not counting cargo which is already reserved for loading)
 528          * @return Cargo on board the vehicle.
 529          */
 530         inline uint AvailableCount() const
 531         {
 532                 return this->count;
 533         }
 534
 535         /**
 536          * Returns sum of cargo reserved for loading onto vehicles.
 537          * @return Cargo reserved for loading.
 538          */
 539         inline uint ReservedCount() const
 540         {
 541                 return this->reserved_count;
 542         }
 543
 544         /**
 545          * Returns total count of cargo at the station, including
 546          * cargo which is already reserved for loading.
 547          * @return Total cargo count.
 548          */
 549         inline uint TotalCount() const
 550         {
 551                 return this->count + this->reserved_count;
 552         }
 553
 554         /* Methods for moving cargo around. First parameter is always maximum
 555          * amount of cargo to be moved. Second parameter is destination (if
 556          * applicable), return value is amount of cargo actually moved. */
 557
 558         uint Reserve(uint max_move, VehicleCargoList *dest, TileIndex load_place, StationIDStack next);
 559         uint Load(uint max_move, VehicleCargoList *dest, TileIndex load_place, StationIDStack next);
 560         uint Truncate(uint max_move = UINT_MAX, StationCargoAmountMap *cargo_per_source = NULL);
 561         uint Reroute(uint max_move, StationCargoList *dest, StationID avoid, StationID avoid2, const GoodsEntry *ge);
 562
 563         /**
 564          * Are two the two CargoPackets mergeable in the context of
 565          * a list of CargoPackets for a Vehicle?
 566          * @param cp1 First CargoPacket.
 567          * @param cp2 Second CargoPacket.
 568          * @return True if they are mergeable.
 569          */
 570         static bool AreMergable(const CargoPacket *cp1, const CargoPacket *cp2)
 571         {
 572                 return cp1->source_xy    == cp2->source_xy &&
 573                                 cp1->days_in_transit == cp2->days_in_transit &&
 574                                 cp1->source_type     == cp2->source_type &&
 575                                 cp1->source_id       == cp2->source_id;
 576         }
 577 };
 578
 579 #endif /* CARGOPACKET_H */