src/script/api/script_stationlist.cpp

   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 script_stationlist.cpp Implementation of ScriptStationList and friends. */
   9
  10 #include "../../stdafx.h"
  11 #include "script_stationlist.hpp"
  12 #include "script_vehicle.hpp"
  13 #include "script_cargo.hpp"
  14 #include "../../station_base.h"
  15 #include "../../vehicle_base.h"
  16
  17 #include "../../safeguards.h"
  18
  19 ScriptStationList::ScriptStationList(ScriptStation::StationType station_type)
  20 {
  21         EnforceDeityOrCompanyModeValid_Void();
  22         bool is_deity = ScriptCompanyMode::IsDeity();
  23         CompanyID owner = ScriptObject::GetCompany();
  24         ScriptList::FillList<Station>(this,
  25                 [is_deity, owner, station_type](const Station *st) {
  26                         return (is_deity || st->owner == owner) && (st->facilities & static_cast<StationFacility>(station_type)) != 0;
  27                 }
  28         );
  29 }
  30
  31 ScriptStationList_Vehicle::ScriptStationList_Vehicle(VehicleID vehicle_id)
  32 {
  33         if (!ScriptVehicle::IsPrimaryVehicle(vehicle_id)) return;
  34
  35         const Vehicle *v = ::Vehicle::Get(vehicle_id);
  36
  37         for (Order *o = v->GetFirstOrder(); o != nullptr; o = o->next) {
  38                 if (o->IsType(OT_GOTO_STATION)) this->AddItem(o->GetDestination());
  39         }
  40 }
  41
  42 ScriptStationList_Cargo::ScriptStationList_Cargo(ScriptStationList_Cargo::CargoMode mode,
  43                 ScriptStationList_Cargo::CargoSelector selector, StationID station_id, CargoID cargo,
  44                 StationID other_station)
  45 {
  46         switch (mode) {
  47                 case CM_WAITING:
  48                         ScriptStationList_CargoWaiting(selector, station_id, cargo, other_station).SwapList(this);
  49                         break;
  50                 case CM_PLANNED:
  51                         ScriptStationList_CargoPlanned(selector, station_id, cargo, other_station).SwapList(this);
  52                         break;
  53                 default:
  54                         NOT_REACHED();
  55         }
  56 }
  57
  58 ScriptStationList_CargoWaiting::ScriptStationList_CargoWaiting(
  59                 ScriptStationList_Cargo::CargoSelector selector, StationID station_id, CargoID cargo,
  60                 StationID other_station)
  61 {
  62         switch (selector) {
  63                 case CS_BY_FROM:
  64                         ScriptStationList_CargoWaitingByFrom(station_id, cargo).SwapList(this);
  65                         break;
  66                 case CS_VIA_BY_FROM:
  67                         ScriptStationList_CargoWaitingViaByFrom(station_id, cargo, other_station).SwapList(this);
  68                         break;
  69                 case CS_BY_VIA:
  70                         ScriptStationList_CargoWaitingByVia(station_id, cargo).SwapList(this);
  71                         break;
  72                 case CS_FROM_BY_VIA:
  73                         ScriptStationList_CargoWaitingFromByVia(station_id, cargo, other_station).SwapList(this);
  74                         break;
  75                 default:
  76                         NOT_REACHED();
  77         }
  78 }
  79
  80 ScriptStationList_CargoPlanned::ScriptStationList_CargoPlanned(
  81                 ScriptStationList_Cargo::CargoSelector selector, StationID station_id, CargoID cargo,
  82                 StationID other_station)
  83 {
  84         switch (selector) {
  85                 case CS_BY_FROM:
  86                         ScriptStationList_CargoPlannedByFrom(station_id, cargo).SwapList(this);
  87                         break;
  88                 case CS_VIA_BY_FROM:
  89                         ScriptStationList_CargoPlannedViaByFrom(station_id, cargo, other_station).SwapList(this);
  90                         break;
  91                 case CS_BY_VIA:
  92                         ScriptStationList_CargoPlannedByVia(station_id, cargo).SwapList(this);
  93                         break;
  94                 case CS_FROM_BY_VIA:
  95                         ScriptStationList_CargoPlannedFromByVia(station_id, cargo, other_station).SwapList(this);
  96                         break;
  97                 default:
  98                         NOT_REACHED();
  99         }
 100 }
 101
 102 class CargoCollector {
 103 public:
 104         CargoCollector(ScriptStationList_Cargo *parent, StationID station_id, CargoID cargo,
 105                         StationID other);
 106         ~CargoCollector() ;
 107
 108         template<ScriptStationList_Cargo::CargoSelector Tselector>
 109         void Update(StationID from, StationID via, uint amount);
 110         const GoodsEntry *GE() const { return ge; }
 111
 112 private:
 113         void SetValue();
 114
 115         ScriptStationList_Cargo *list;
 116         const GoodsEntry *ge;
 117         StationID other_station;
 118
 119         StationID last_key;
 120         uint amount;
 121 };
 122
 123 CargoCollector::CargoCollector(ScriptStationList_Cargo *parent,
 124                 StationID station_id, CargoID cargo, StationID other) :
 125         list(parent), ge(nullptr), other_station(other), last_key(INVALID_STATION), amount(0)
 126 {
 127         if (!ScriptStation::IsValidStation(station_id)) return;
 128         if (!ScriptCargo::IsValidCargo(cargo)) return;
 129         this->ge = &(Station::Get(station_id)->goods[cargo]);
 130 }
 131
 132 CargoCollector::~CargoCollector()
 133 {
 134         this->SetValue();
 135 }
 136
 137 void CargoCollector::SetValue()
 138 {
 139         if (this->amount > 0) {
 140                 if (this->list->HasItem(this->last_key)) {
 141                         this->list->SetValue(this->last_key,
 142                                         this->list->GetValue(this->last_key) + this->amount);
 143                 } else {
 144                         this->list->AddItem(this->last_key, this->amount);
 145                 }
 146         }
 147 }
 148
 149 template<ScriptStationList_Cargo::CargoSelector Tselector>
 150 void CargoCollector::Update(StationID from, StationID via, uint amount)
 151 {
 152         StationID key = INVALID_STATION;
 153         switch (Tselector) {
 154                 case ScriptStationList_Cargo::CS_VIA_BY_FROM:
 155                         if (via != this->other_station) return;
 156                         [[fallthrough]];
 157                 case ScriptStationList_Cargo::CS_BY_FROM:
 158                         key = from;
 159                         break;
 160                 case ScriptStationList_Cargo::CS_FROM_BY_VIA:
 161                         if (from != this->other_station) return;
 162                         [[fallthrough]];
 163                 case ScriptStationList_Cargo::CS_BY_VIA:
 164                         key = via;
 165                         break;
 166         }
 167         if (key == this->last_key) {
 168                 this->amount += amount;
 169         } else {
 170                 this->SetValue();
 171                 this->amount = amount;
 172                 this->last_key = key;
 173         }
 174 }
 175
 176
 177 template<ScriptStationList_Cargo::CargoSelector Tselector>
 178 void ScriptStationList_CargoWaiting::Add(StationID station_id, CargoID cargo, StationID other_station)
 179 {
 180         CargoCollector collector(this, station_id, cargo, other_station);
 181         if (collector.GE() == nullptr) return;
 182
 183         StationCargoList::ConstIterator iter = collector.GE()->cargo.Packets()->begin();
 184         StationCargoList::ConstIterator end = collector.GE()->cargo.Packets()->end();
 185         for (; iter != end; ++iter) {
 186                 collector.Update<Tselector>((*iter)->GetFirstStation(), iter.GetKey(), (*iter)->Count());
 187         }
 188 }
 189
 190
 191 template<ScriptStationList_Cargo::CargoSelector Tselector>
 192 void ScriptStationList_CargoPlanned::Add(StationID station_id, CargoID cargo, StationID other_station)
 193 {
 194         CargoCollector collector(this, station_id, cargo, other_station);
 195         if (collector.GE() == nullptr) return;
 196
 197         FlowStatMap::const_iterator iter = collector.GE()->flows.begin();
 198         FlowStatMap::const_iterator end = collector.GE()->flows.end();
 199         for (; iter != end; ++iter) {
 200                 const FlowStat::SharesMap *shares = iter->second.GetShares();
 201                 uint prev = 0;
 202                 for (FlowStat::SharesMap::const_iterator flow_iter = shares->begin();
 203                                 flow_iter != shares->end(); ++flow_iter) {
 204                         collector.Update<Tselector>(iter->first, flow_iter->second, flow_iter->first - prev);
 205                         prev = flow_iter->first;
 206                 }
 207         }
 208 }
 209
 210 ScriptStationList_CargoWaitingByFrom::ScriptStationList_CargoWaitingByFrom(StationID station_id,
 211                 CargoID cargo)
 212 {
 213         this->Add<CS_BY_FROM>(station_id, cargo);
 214 }
 215
 216 ScriptStationList_CargoWaitingViaByFrom::ScriptStationList_CargoWaitingViaByFrom(
 217                 StationID station_id, CargoID cargo, StationID via)
 218 {
 219         CargoCollector collector(this, station_id, cargo, via);
 220         if (collector.GE() == nullptr) return;
 221
 222         std::pair<StationCargoList::ConstIterator, StationCargoList::ConstIterator> range =
 223                         collector.GE()->cargo.Packets()->equal_range(via);
 224         for (StationCargoList::ConstIterator iter = range.first; iter != range.second; ++iter) {
 225                 collector.Update<CS_VIA_BY_FROM>((*iter)->GetFirstStation(), iter.GetKey(), (*iter)->Count());
 226         }
 227 }
 228
 229
 230 ScriptStationList_CargoWaitingByVia::ScriptStationList_CargoWaitingByVia(StationID station_id,
 231                 CargoID cargo)
 232 {
 233         this->Add<CS_BY_VIA>(station_id, cargo);
 234 }
 235
 236 ScriptStationList_CargoWaitingFromByVia::ScriptStationList_CargoWaitingFromByVia(
 237                 StationID station_id, CargoID cargo, StationID from)
 238 {
 239         this->Add<CS_FROM_BY_VIA>(station_id, cargo, from);
 240 }
 241
 242 ScriptStationList_CargoPlannedByFrom::ScriptStationList_CargoPlannedByFrom(StationID station_id,
 243                 CargoID cargo)
 244 {
 245         this->Add<CS_BY_FROM>(station_id, cargo);
 246 }
 247
 248 ScriptStationList_CargoPlannedViaByFrom::ScriptStationList_CargoPlannedViaByFrom(
 249                 StationID station_id, CargoID cargo, StationID via)
 250 {
 251         this->Add<CS_VIA_BY_FROM>(station_id, cargo, via);
 252 }
 253
 254
 255 ScriptStationList_CargoPlannedByVia::ScriptStationList_CargoPlannedByVia(StationID station_id,
 256                 CargoID cargo)
 257 {
 258         this->Add<CS_BY_VIA>(station_id, cargo);
 259 }
 260
 261
 262 ScriptStationList_CargoPlannedFromByVia::ScriptStationList_CargoPlannedFromByVia(
 263                 StationID station_id, CargoID cargo, StationID from)
 264 {
 265         CargoCollector collector(this, station_id, cargo, from);
 266         if (collector.GE() == nullptr) return;
 267
 268         FlowStatMap::const_iterator iter = collector.GE()->flows.find(from);
 269         if (iter == collector.GE()->flows.end()) return;
 270         const FlowStat::SharesMap *shares = iter->second.GetShares();
 271         uint prev = 0;
 272         for (FlowStat::SharesMap::const_iterator flow_iter = shares->begin();
 273                         flow_iter != shares->end(); ++flow_iter) {
 274                 collector.Update<CS_FROM_BY_VIA>(iter->first, flow_iter->second, flow_iter->first - prev);
 275                 prev = flow_iter->first;
 276         }
 277 }