cargopacket.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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#ifndef CARGOPACKET_H
#define CARGOPACKET_H
 
#include "core/pool_type.hpp"
#include "economy_type.h"
#include "station_type.h"
#include "order_type.h"
#include "cargo_type.h"
#include "source_type.h"
#include "vehicle_type.h"
#include "core/multimap.hpp"
#include "saveload/saveload.h"

using CargoPacketID = PoolID<uint32_t, struct CargoPacketIDTag, 0xFFF000, 0xFFFFFF>;
struct CargoPacket;

using CargoPacketPool = Pool<CargoPacket, CargoPacketID, 1024, PoolType::Normal, true>;
extern CargoPacketPool _cargopacket_pool;
 
struct GoodsEntry; // forward-declare for Stage() and RerouteStalePackets()
 
template <class Tinst, class Tcont> class CargoList;
class StationCargoList; // forward-declare, so we can use it in VehicleCargoList.
extern SaveLoadTable GetCargoPacketDesc();

struct CargoPacket : CargoPacketPool::PoolItem<&_cargopacket_pool> {
private:
  uint16_t count = 0; 
  uint16_t periods_in_transit = 0; 
 
  Money feeder_share = 0; 
 
  TileIndex source_xy = INVALID_TILE; 
  Coord2D<int16_t> travelled{0, 0}; 
 
  Source source{Source::Invalid, SourceType::Industry}; 
 
#ifdef WITH_ASSERT
  bool in_vehicle = false; 
#endif /* WITH_ASSERT */
 
  StationID first_station = StationID::Invalid(); 
  StationID next_hop = StationID::Invalid(); 

  template <class Tinst, class Tcont> friend class CargoList;
  friend class VehicleCargoList;
  friend class StationCargoList;
  friend SaveLoadTable GetCargoPacketDesc();
public:
  static const uint16_t MAX_COUNT = UINT16_MAX;
 
  CargoPacket(CargoPacketID index);
  CargoPacket(CargoPacketID index, StationID first_station, uint16_t count, Source source);
  CargoPacket(CargoPacketID index, uint16_t count, uint16_t periods_in_transit, StationID first_station, TileIndex source_xy, Money feeder_share);
  CargoPacket(CargoPacketID index, uint16_t count, Money feeder_share, CargoPacket &original);

  ~CargoPacket() { }
 
  CargoPacket *Split(uint new_size);
  void Merge(CargoPacket *cp);
  void Reduce(uint count);

  void SetNextHop(StationID next_hop)
  {
    this->next_hop = next_hop;
  }

  void UpdateLoadingTile(TileIndex tile)
  {
    if (this->source_xy == INVALID_TILE) {
      this->source_xy = tile;
    }
 
#ifdef WITH_ASSERT
    assert(!this->in_vehicle);
    this->in_vehicle = true;
#endif /* WITH_ASSERT */
 
    /* We want to calculate the vector from tile-unload to tile-load. As
     * we currently only know the latter, add it. When we know where we unload,
     * we subtract is, giving us our vector (unload - load). */
    this->travelled.x += TileX(tile);
    this->travelled.y += TileY(tile);
  }

  void UpdateUnloadingTile(TileIndex tile)
  {
#ifdef WITH_ASSERT
    assert(this->in_vehicle);
    this->in_vehicle = false;
#endif /* WITH_ASSERT */
 
    this->travelled.x -= TileX(tile);
    this->travelled.y -= TileY(tile);
  }

  void AddFeederShare(Money new_share)
  {
    this->feeder_share += new_share;
  }

  inline uint16_t Count() const
  {
    return this->count;
  }

  inline Money GetFeederShare() const
  {
    return this->feeder_share;
  }

  inline Money GetFeederShare(uint part) const
  {
    return this->feeder_share * part / static_cast<uint>(this->count);
  }

  inline uint16_t GetPeriodsInTransit() const
  {
    return this->periods_in_transit;
  }

  inline Source GetSource() const
  {
    return this->source;
  }

  inline StationID GetFirstStation() const
  {
    return this->first_station;
  }

  inline uint GetDistance(TileIndex current_tile) const
  {
    assert(this->source_xy != INVALID_TILE);
#ifdef WITH_ASSERT
    assert(this->in_vehicle);
#endif /* WITH_ASSERT */
 
    /* Distance is always requested when the cargo is still inside the
     * vehicle. So first finish the calculation for travelled to
     * become a vector. */
    auto local_travelled = travelled;
    local_travelled.x -= TileX(current_tile);
    local_travelled.y -= TileY(current_tile);
 
    /* Cargo-movement is a vector that indicates how much the cargo has
     * actually traveled in a vehicle. This is the distance you get paid
     * for. However, one could construct a route where this vector would
     * be really long. To not overpay the player, cap out at the distance
     * between source and destination.
     *
     * This way of calculating is to counter people moving cargo for free
     * and instantly in stations, where you deliver it in one part of the
     * station and pick it up in another. By using the actual distance
     * traveled in a vehicle, using this trick doesn't give you more money.
     *
     * However, especially in large networks with large transfer station,
     * etc, one could actually make the route a lot longer. In that case,
     * use the actual distance between source and destination.
     */
 
    uint distance_travelled = abs(local_travelled.x) + abs(local_travelled.y);
    uint distance_source_dest = DistanceManhattan(this->source_xy, current_tile);
    return std::min(distance_travelled, distance_source_dest);
  }

  inline StationID GetNextHop() const
  {
    return this->next_hop;
  }
 
  static void InvalidateAllFrom(Source src);
  static void InvalidateAllFrom(StationID sid);
  static void AfterLoad();
};

template <class Tinst, class Tcont>
class CargoList {
public:
  typedef typename Tcont::iterator Iterator;
  typedef typename Tcont::reverse_iterator ReverseIterator;
  typedef typename Tcont::const_iterator ConstIterator;
  typedef typename Tcont::const_reverse_iterator ConstReverseIterator;

  enum MoveToAction : uint8_t {
    MTA_BEGIN = 0,
    MTA_TRANSFER = 0, 
    MTA_DELIVER,      
    MTA_KEEP,         
    MTA_LOAD,         
    MTA_END,
    NUM_MOVE_TO_ACTION = MTA_END
  };
 
protected:
  uint count = 0; 
  uint64_t cargo_periods_in_transit = 0; 
 
  Tcont packets{}; 
 
  void AddToCache(const CargoPacket *cp);
 
  void RemoveFromCache(const CargoPacket *cp, uint count);
 
  static bool TryMerge(CargoPacket *cp, CargoPacket *icp);
 
public:
  CargoList() {}
 
  ~CargoList();
 
  void OnCleanPool();

  inline const Tcont *Packets() const
  {
    return &this->packets;
  }

  inline uint PeriodsInTransit() const
  {
    return this->count == 0 ? 0 : this->cargo_periods_in_transit / this->count;
  }
 
  void InvalidateCache();
};
 
typedef std::list<CargoPacket *> CargoPacketList;

class VehicleCargoList : public CargoList<VehicleCargoList, CargoPacketList> {
protected:
  typedef CargoList<VehicleCargoList, CargoPacketList> Parent;
 
  Money feeder_share;                     
  uint action_counts[NUM_MOVE_TO_ACTION]; 
 
  template <class Taction>
  void ShiftCargo(Taction action);
 
  template <class Taction>
  void PopCargo(Taction action);

  inline void AssertCountConsistency() const
  {
    assert(this->action_counts[MTA_KEEP] +
        this->action_counts[MTA_DELIVER] +
        this->action_counts[MTA_TRANSFER] +
        this->action_counts[MTA_LOAD] == this->count);
  }
 
  void AddToCache(const CargoPacket *cp);
  void RemoveFromCache(const CargoPacket *cp, uint count);
 
  void AddToMeta(const CargoPacket *cp, MoveToAction action);
  void RemoveFromMeta(const CargoPacket *cp, MoveToAction action, uint count);
 
  static MoveToAction ChooseAction(const CargoPacket *cp, StationID cargo_next,
      StationID current_station, bool accepted, std::span<const StationID> next_station);
 
public:
  friend class StationCargoList;
  friend class CargoList<VehicleCargoList, CargoPacketList>;
  /* So we can use private/protected variables in the saveload code */
  friend class SlVehicleCommon;
 
  friend class CargoShift;
  friend class CargoTransfer;
  friend class CargoDelivery;
  template <class Tsource>
  friend class CargoRemoval;
  friend class CargoReturn;
  friend class VehicleCargoReroute;

  inline StationID GetFirstStation() const
  {
    return this->count == 0 ? StationID::Invalid() : this->packets.front()->first_station;
  }

  inline Money GetFeederShare() const
  {
    return this->feeder_share;
  }

  inline uint ActionCount(MoveToAction action) const
  {
    return this->action_counts[action];
  }

  inline uint StoredCount() const
  {
    return this->count - this->action_counts[MTA_LOAD];
  }

  inline uint TotalCount() const
  {
    return this->count;
  }

  inline uint ReservedCount() const
  {
    return this->action_counts[MTA_LOAD];
  }

  inline uint UnloadCount() const
  {
    return this->action_counts[MTA_TRANSFER] + this->action_counts[MTA_DELIVER];
  }

  inline uint RemainingCount() const
  {
    return this->action_counts[MTA_KEEP] + this->action_counts[MTA_LOAD];
  }
 
  void Append(CargoPacket *cp, MoveToAction action = MTA_KEEP);
 
  void AgeCargo();
 
  void InvalidateCache();
 
  bool Stage(bool accepted, StationID current_station, std::span<const StationID> next_station, OrderUnloadType unload_type, const GoodsEntry *ge, CargoType cargo, CargoPayment *payment, TileIndex current_tile);

  inline void KeepAll()
  {
    this->action_counts[MTA_DELIVER] = this->action_counts[MTA_TRANSFER] = this->action_counts[MTA_LOAD] = 0;
    this->action_counts[MTA_KEEP] = this->count;
  }
 
  /* Methods for moving cargo around. First parameter is always maximum
   * amount of cargo to be moved. Second parameter is destination (if
   * applicable), return value is amount of cargo actually moved. */
 
  template <MoveToAction Tfrom, MoveToAction Tto>
  uint Reassign(uint max_move);
  uint Return(uint max_move, StationCargoList *dest, StationID next_station, TileIndex current_tile);
  uint Unload(uint max_move, StationCargoList *dest, CargoType cargo, CargoPayment *payment, TileIndex current_tile);
  uint Shift(uint max_move, VehicleCargoList *dest);
  uint Truncate(uint max_move = UINT_MAX);
  uint Reroute(uint max_move, VehicleCargoList *dest, StationID avoid, StationID avoid2, const GoodsEntry *ge);

  static bool AreMergable(const CargoPacket *cp1, const CargoPacket *cp2)
  {
    return cp1->source_xy == cp2->source_xy &&
        cp1->periods_in_transit == cp2->periods_in_transit &&
        cp1->first_station == cp2->first_station &&
        cp1->source == cp2->source;
  }
};
 
typedef MultiMap<StationID, CargoPacket *> StationCargoPacketMap;
typedef std::map<StationID, uint> StationCargoAmountMap;

class StationCargoList : public CargoList<StationCargoList, StationCargoPacketMap> {
protected:
  typedef CargoList<StationCargoList, StationCargoPacketMap> Parent;
 
  uint reserved_count; 
 
public:
  friend class CargoList<StationCargoList, StationCargoPacketMap>;
  /* So we can use private/protected variables in the saveload code */
  friend class SlStationGoods;
 
  friend class CargoLoad;
  friend class CargoTransfer;
  template <class Tsource>
  friend class CargoRemoval;
  friend class CargoReservation;
  friend class CargoReturn;
  friend class StationCargoReroute;
 
  static void InvalidateAllFrom(Source src);
 
  template <class Taction>
  bool ShiftCargo(Taction &action, StationID next);
 
  template <class Taction>
  uint ShiftCargo(Taction action, std::span<const StationID> next, bool include_invalid);
 
  void Append(CargoPacket *cp, StationID next);

  inline bool HasCargoFor(std::span<const StationID> next) const
  {
    for (const StationID &station : next) {
      if (this->packets.find(station) != this->packets.end()) return true;
    }
    /* Packets for StationID::Invalid() can go anywhere. */
    return this->packets.find(StationID::Invalid()) != this->packets.end();
  }

  inline StationID GetFirstStation() const
  {
    return this->count == 0 ? StationID::Invalid() : this->packets.begin()->second.front()->first_station;
  }

  inline uint AvailableCount() const
  {
    return this->count;
  }

  inline uint ReservedCount() const
  {
    return this->reserved_count;
  }

  inline uint TotalCount() const
  {
    return this->count + this->reserved_count;
  }
 
  /* Methods for moving cargo around. First parameter is always maximum
   * amount of cargo to be moved. Second parameter is destination (if
   * applicable), return value is amount of cargo actually moved. */
 
  uint Reserve(uint max_move, VehicleCargoList *dest, std::span<const StationID> next, TileIndex current_tile);
  uint Load(uint max_move, VehicleCargoList *dest, std::span<const StationID> next, TileIndex current_tile);
  uint Truncate(uint max_move = UINT_MAX, StationCargoAmountMap *cargo_per_source = nullptr);
  uint Reroute(uint max_move, StationCargoList *dest, StationID avoid, StationID avoid2, const GoodsEntry *ge);

  static bool AreMergable(const CargoPacket *cp1, const CargoPacket *cp2)
  {
    return cp1->source_xy == cp2->source_xy &&
        cp1->periods_in_transit == cp2->periods_in_transit &&
        cp1->first_station == cp2->first_station &&
        cp1->source == cp2->source;
  }
};
 
#endif /* CARGOPACKET_H */