src/cargomonitor.cpp

   1 /* $Id$ */
   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 cargomonitor.cpp Implementation of the cargo transport monitoring. */
  11
  12 #include "stdafx.h"
  13 #include "cargomonitor.h"
  14 #include "station_base.h"
  15
  16 #include "safeguards.h"
  17
  18 CargoMonitorMap _cargo_pickups;    ///< Map of monitored pick-ups   to the amount since last query/activation.
  19 CargoMonitorMap _cargo_deliveries; ///< Map of monitored deliveries to the amount since last query/activation.
  20
  21 /**
  22  * Helper method for #ClearCargoPickupMonitoring and #ClearCargoDeliveryMonitoring.
  23  * Clears all monitors that belong to the specified company or all if #INVALID_OWNER
  24  * is specified as company.
  25  * @param cargo_monitor_map reference to the cargo monitor map to operate on.
  26  * @param company company to clear cargo monitors for or #INVALID_OWNER if all cargo monitors should be cleared.
  27  */
  28 static void ClearCargoMonitoring(CargoMonitorMap &cargo_monitor_map, CompanyID company = INVALID_OWNER)
  29 {
  30         if (company == INVALID_OWNER) {
  31                 cargo_monitor_map.clear();
  32                 return;
  33         }
  34
  35         CargoMonitorMap::iterator next;
  36         for (CargoMonitorMap::iterator it = cargo_monitor_map.begin(); it != cargo_monitor_map.end(); it = next) {
  37                 next = it;
  38                 next++;
  39                 if (DecodeMonitorCompany(it->first) == company) {
  40                         cargo_monitor_map.erase(it);
  41                 }
  42         }
  43 }
  44
  45 /**
  46  * Clear all pick-up cargo monitors.
  47  * @param company clear all pick-up monitors for this company or if #INVALID_OWNER
  48  * is passed, all pick-up monitors are cleared regardless of company.
  49  */
  50 void ClearCargoPickupMonitoring(CompanyID company)
  51 {
  52         ClearCargoMonitoring(_cargo_pickups, company);
  53 }
  54
  55 /**
  56  * Clear all delivery cargo monitors.
  57  * @param company clear all delivery monitors for this company or if #INVALID_OWNER
  58  * is passed, all delivery monitors are cleared regardless of company.
  59  */
  60 void ClearCargoDeliveryMonitoring(CompanyID company)
  61 {
  62         ClearCargoMonitoring(_cargo_deliveries, company);
  63 }
  64
  65 /**
  66  * Get and reset the amount associated with a cargo monitor.
  67  * @param[in,out] monitor_map Monitoring map to search (and reset for the queried entry).
  68  * @param monitor Cargo monitor to query/reset.
  69  * @param keep_monitoring After returning from this call, continue monitoring.
  70  * @return Amount collected since last query/activation for the monitored combination.
  71  */
  72 static int32 GetAmount(CargoMonitorMap &monitor_map, CargoMonitorID monitor, bool keep_monitoring)
  73 {
  74         CargoMonitorMap::iterator iter = monitor_map.find(monitor);
  75         if (iter == monitor_map.end()) {
  76                 if (keep_monitoring) {
  77                         std::pair<CargoMonitorID, uint32> p(monitor, 0);
  78                         monitor_map.insert(p);
  79                 }
  80                 return 0;
  81         } else {
  82                 int32 result = iter->second;
  83                 iter->second = 0;
  84                 if (!keep_monitoring) monitor_map.erase(iter);
  85                 return result;
  86         }
  87 }
  88
  89 /**
  90  * Get the amount of cargo delivered for the given cargo monitor since activation or last query.
  91  * @param monitor Cargo monitor to query.
  92  * @param keep_monitoring After returning from this call, continue monitoring.
  93  * @return Amount of delivered cargo for the monitored combination.
  94  */
  95 int32 GetDeliveryAmount(CargoMonitorID monitor, bool keep_monitoring)
  96 {
  97         return GetAmount(_cargo_deliveries, monitor, keep_monitoring);
  98 }
  99
 100 /**
 101  * Get the amount of cargo picked up for the given cargo monitor since activation or last query.
 102  * @param monitor Monitoring number to query.
 103  * @param keep_monitoring After returning from this call, continue monitoring.
 104  * @return Amount of picked up cargo for the monitored combination.
 105  * @note Cargo pick up is counted on final delivery, to prevent users getting credit for picking up cargo without delivering it.
 106  */
 107 int32 GetPickupAmount(CargoMonitorID monitor, bool keep_monitoring)
 108 {
 109         return GetAmount(_cargo_pickups, monitor, keep_monitoring);
 110 }
 111
 112 /**
 113  * Cargo was delivered to its final destination, update the pickup and delivery maps.
 114  * @param cargo_type type of cargo.
 115  * @param company company delivering the cargo.
 116  * @param amount Amount of cargo delivered.
 117  * @param src_type type of \a src.
 118  * @param src index of source.
 119  * @param st station where the cargo is delivered to.
 120  */
 121 void AddCargoDelivery(CargoID cargo_type, CompanyID company, uint32 amount, SourceType src_type, SourceID src, const Station *st)
 122 {
 123         if (amount == 0) return;
 124
 125         if (src != INVALID_SOURCE) {
 126                 /* Handle pickup update. */
 127                 switch (src_type) {
 128                         case ST_INDUSTRY: {
 129                                 CargoMonitorID num = EncodeCargoIndustryMonitor(company, cargo_type, src);
 130                                 CargoMonitorMap::iterator iter = _cargo_pickups.find(num);
 131                                 if (iter != _cargo_pickups.end()) iter->second += amount;
 132                                 break;
 133                         }
 134                         case ST_TOWN: {
 135                                 CargoMonitorID num = EncodeCargoTownMonitor(company, cargo_type, src);
 136                                 CargoMonitorMap::iterator iter = _cargo_pickups.find(num);
 137                                 if (iter != _cargo_pickups.end()) iter->second += amount;
 138                                 break;
 139                         }
 140                         default: break;
 141                 }
 142         }
 143
 144         /* Handle delivery.
 145          * Note that delivery in the right area is sufficient to prevent trouble with neighbouring industries or houses. */
 146
 147         /* Town delivery. */
 148         CargoMonitorID num = EncodeCargoTownMonitor(company, cargo_type, st->town->index);
 149         CargoMonitorMap::iterator iter = _cargo_deliveries.find(num);
 150         if (iter != _cargo_deliveries.end()) iter->second += amount;
 151
 152         /* Industry delivery. */
 153         for (const Industry * const *ip = st->industries_near.Begin(); ip != st->industries_near.End(); ip++) {
 154                 CargoMonitorID num = EncodeCargoIndustryMonitor(company, cargo_type, (*ip)->index);
 155                 CargoMonitorMap::iterator iter = _cargo_deliveries.find(num);
 156                 if (iter != _cargo_deliveries.end()) iter->second += amount;
 157         }
 158 }
 159