src/script/api/script_station.cpp

   1 /* $Id: script_station.cpp 26398 2014-03-11 22:08:58Z zuu $ */
   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 script_station.cpp Implementation of ScriptStation. */
  11
  12 #include "../../stdafx.h"
  13 #include "script_station.hpp"
  14 #include "script_map.hpp"
  15 #include "script_town.hpp"
  16 #include "script_cargo.hpp"
  17 #include "../../station_base.h"
  18 #include "../../roadstop_base.h"
  19 #include "../../town.h"
  20
  21 #include "../../safeguards.h"
  22
  23 /* static */ bool ScriptStation::IsValidStation(StationID station_id)
  24 {
  25         const Station *st = ::Station::GetIfValid(station_id);
  26         return st != NULL && (st->owner == ScriptObject::GetCompany() || ScriptObject::GetCompany() == OWNER_DEITY || st->owner == OWNER_NONE);
  27 }
  28
  29 /* static */ ScriptCompany::CompanyID ScriptStation::GetOwner(StationID station_id)
  30 {
  31         if (!IsValidStation(station_id)) return ScriptCompany::COMPANY_INVALID;
  32
  33         return static_cast<ScriptCompany::CompanyID>((int)::Station::Get(station_id)->owner);
  34 }
  35
  36 /* static */ StationID ScriptStation::GetStationID(TileIndex tile)
  37 {
  38         if (!::IsValidTile(tile) || !::IsTileType(tile, MP_STATION)) return INVALID_STATION;
  39         return ::GetStationIndex(tile);
  40 }
  41
  42 template<bool Tfrom, bool Tvia>
  43 /* static */ bool ScriptStation::IsCargoRequestValid(StationID station_id,
  44                 StationID from_station_id, StationID via_station_id, CargoID cargo_id)
  45 {
  46         if (!IsValidStation(station_id)) return false;
  47         if (Tfrom && !IsValidStation(from_station_id) && from_station_id != STATION_INVALID) return false;
  48         if (Tvia && !IsValidStation(via_station_id) && via_station_id != STATION_INVALID) return false;
  49         if (!ScriptCargo::IsValidCargo(cargo_id)) return false;
  50         return true;
  51 }
  52
  53 template<bool Tfrom, bool Tvia>
  54 /* static */ int32 ScriptStation::CountCargoWaiting(StationID station_id,
  55                 StationID from_station_id, StationID via_station_id, CargoID cargo_id)
  56 {
  57         if (!ScriptStation::IsCargoRequestValid<Tfrom, Tvia>(station_id, from_station_id,
  58                         via_station_id, cargo_id)) {
  59                 return -1;
  60         }
  61
  62         const StationCargoList &cargo_list = ::Station::Get(station_id)->goods[cargo_id].cargo;
  63         if (!Tfrom && !Tvia) return cargo_list.TotalCount();
  64
  65         uint16 cargo_count = 0;
  66         std::pair<StationCargoList::ConstIterator, StationCargoList::ConstIterator> range = Tvia ?
  67                                 cargo_list.Packets()->equal_range(via_station_id) :
  68                                 std::make_pair(StationCargoList::ConstIterator(cargo_list.Packets()->begin()),
  69                                                 StationCargoList::ConstIterator(cargo_list.Packets()->end()));
  70         for (StationCargoList::ConstIterator it = range.first; it != range.second; it++) {
  71                 const CargoPacket *cp = *it;
  72                 if (!Tfrom || cp->SourceStation() == from_station_id) cargo_count += cp->Count();
  73         }
  74
  75         return cargo_count;
  76 }
  77
  78 /* static */ int32 ScriptStation::GetCargoWaiting(StationID station_id, CargoID cargo_id)
  79 {
  80         return CountCargoWaiting<false, false>(station_id, STATION_INVALID, STATION_INVALID, cargo_id);
  81 }
  82
  83 /* static */ int32 ScriptStation::GetCargoWaitingFrom(StationID station_id,
  84                 StationID from_station_id, CargoID cargo_id)
  85 {
  86         return CountCargoWaiting<true, false>(station_id, from_station_id, STATION_INVALID, cargo_id);
  87 }
  88
  89 /* static */ int32 ScriptStation::GetCargoWaitingVia(StationID station_id,
  90                 StationID via_station_id, CargoID cargo_id)
  91 {
  92         return CountCargoWaiting<false, true>(station_id, STATION_INVALID, via_station_id, cargo_id);
  93 }
  94
  95 /* static */ int32 ScriptStation::GetCargoWaitingFromVia(StationID station_id,
  96                 StationID from_station_id, StationID via_station_id, CargoID cargo_id)
  97 {
  98         return CountCargoWaiting<true, true>(station_id, from_station_id, via_station_id, cargo_id);
  99 }
 100
 101 template<bool Tfrom, bool Tvia>
 102 /* static */ int32 ScriptStation::CountCargoPlanned(StationID station_id,
 103                 StationID from_station_id, StationID via_station_id, CargoID cargo_id)
 104 {
 105         if (!ScriptStation::IsCargoRequestValid<Tfrom, Tvia>(station_id, from_station_id,
 106                         via_station_id, cargo_id)) {
 107                 return -1;
 108         }
 109
 110         const FlowStatMap &flows = ::Station::Get(station_id)->goods[cargo_id].flows;
 111         if (Tfrom) {
 112                 return Tvia ? flows.GetFlowFromVia(from_station_id, via_station_id) :
 113                                           flows.GetFlowFrom(from_station_id);
 114         } else {
 115                 return Tvia ? flows.GetFlowVia(via_station_id) : flows.GetFlow();
 116         }
 117 }
 118
 119 /* static */ int32 ScriptStation::GetCargoPlanned(StationID station_id, CargoID cargo_id)
 120 {
 121         return CountCargoPlanned<false, false>(station_id, STATION_INVALID, STATION_INVALID, cargo_id);
 122 }
 123
 124 /* static */ int32 ScriptStation::GetCargoPlannedFrom(StationID station_id,
 125                 StationID from_station_id, CargoID cargo_id)
 126 {
 127         return CountCargoPlanned<true, false>(station_id, from_station_id, STATION_INVALID, cargo_id);
 128 }
 129
 130 /* static */ int32 ScriptStation::GetCargoPlannedVia(StationID station_id,
 131                 StationID via_station_id, CargoID cargo_id)
 132 {
 133         return CountCargoPlanned<false, true>(station_id, STATION_INVALID, via_station_id, cargo_id);
 134 }
 135
 136 /* static */ int32 ScriptStation::GetCargoPlannedFromVia(StationID station_id,
 137                 StationID from_station_id, StationID via_station_id, CargoID cargo_id)
 138 {
 139         return CountCargoPlanned<true, true>(station_id, from_station_id, via_station_id, cargo_id);
 140 }
 141
 142 /* static */ bool ScriptStation::HasCargoRating(StationID station_id, CargoID cargo_id)
 143 {
 144         if (!IsValidStation(station_id)) return false;
 145         if (!ScriptCargo::IsValidCargo(cargo_id)) return false;
 146
 147         return ::Station::Get(station_id)->goods[cargo_id].HasRating();
 148 }
 149
 150 /* static */ int32 ScriptStation::GetCargoRating(StationID station_id, CargoID cargo_id)
 151 {
 152         if (!ScriptStation::HasCargoRating(station_id, cargo_id)) return -1;
 153
 154         return ::ToPercent8(::Station::Get(station_id)->goods[cargo_id].rating);
 155 }
 156
 157 /* static */ int32 ScriptStation::GetCoverageRadius(ScriptStation::StationType station_type)
 158 {
 159         if (station_type == STATION_AIRPORT) return -1;
 160         if (!HasExactlyOneBit(station_type)) return -1;
 161
 162         if (!_settings_game.station.modified_catchment) return CA_UNMODIFIED;
 163
 164         switch (station_type) {
 165                 case STATION_TRAIN:      return CA_TRAIN;
 166                 case STATION_TRUCK_STOP: return CA_TRUCK;
 167                 case STATION_BUS_STOP:   return CA_BUS;
 168                 case STATION_DOCK:       return CA_DOCK;
 169                 default:                 return CA_NONE;
 170         }
 171 }
 172
 173 /* static */ int32 ScriptStation::GetStationCoverageRadius(StationID station_id)
 174 {
 175         if (!IsValidStation(station_id)) return -1;
 176
 177         return Station::Get(station_id)->GetCatchmentRadius();
 178 }
 179
 180 /* static */ int32 ScriptStation::GetDistanceManhattanToTile(StationID station_id, TileIndex tile)
 181 {
 182         if (!IsValidStation(station_id)) return -1;
 183
 184         return ScriptMap::DistanceManhattan(tile, GetLocation(station_id));
 185 }
 186
 187 /* static */ int32 ScriptStation::GetDistanceSquareToTile(StationID station_id, TileIndex tile)
 188 {
 189         if (!IsValidStation(station_id)) return -1;
 190
 191         return ScriptMap::DistanceSquare(tile, GetLocation(station_id));
 192 }
 193
 194 /* static */ bool ScriptStation::IsWithinTownInfluence(StationID station_id, TownID town_id)
 195 {
 196         if (!IsValidStation(station_id)) return false;
 197
 198         return ScriptTown::IsWithinTownInfluence(town_id, GetLocation(station_id));
 199 }
 200
 201 /* static */ bool ScriptStation::HasStationType(StationID station_id, StationType station_type)
 202 {
 203         if (!IsValidStation(station_id)) return false;
 204         if (!HasExactlyOneBit(station_type)) return false;
 205
 206         return (::Station::Get(station_id)->facilities & station_type) != 0;
 207 }
 208
 209 /* static */ bool ScriptStation::HasRoadType(StationID station_id, ScriptRoad::RoadType road_type)
 210 {
 211         if (!IsValidStation(station_id)) return false;
 212         if (!ScriptRoad::IsRoadTypeAvailable(road_type)) return false;
 213
 214         ::RoadTypes r = RoadTypeToRoadTypes((::RoadType)road_type);
 215
 216         for (const RoadStop *rs = ::Station::Get(station_id)->GetPrimaryRoadStop(ROADSTOP_BUS); rs != NULL; rs = rs->next) {
 217                 if ((::GetRoadTypes(rs->xy) & r) != 0) return true;
 218         }
 219         for (const RoadStop *rs = ::Station::Get(station_id)->GetPrimaryRoadStop(ROADSTOP_TRUCK); rs != NULL; rs = rs->next) {
 220                 if ((::GetRoadTypes(rs->xy) & r) != 0) return true;
 221         }
 222
 223         return false;
 224 }
 225
 226 /* static */ TownID ScriptStation::GetNearestTown(StationID station_id)
 227 {
 228         if (!IsValidStation(station_id)) return INVALID_TOWN;
 229
 230         return ::Station::Get(station_id)->town->index;
 231 }
 232
 233 /* static */ bool ScriptStation::IsAirportClosed(StationID station_id)
 234 {
 235         EnforcePrecondition(false, IsValidStation(station_id));
 236         EnforcePrecondition(false, HasStationType(station_id, STATION_AIRPORT));
 237
 238         return (::Station::Get(station_id)->airport.flags & AIRPORT_CLOSED_block) != 0;
 239 }
 240
 241 /* static */ bool ScriptStation::OpenCloseAirport(StationID station_id)
 242 {
 243         EnforcePrecondition(false, IsValidStation(station_id));
 244         EnforcePrecondition(false, HasStationType(station_id, STATION_AIRPORT));
 245
 246         return ScriptObject::DoCommand(0, station_id, 0, CMD_OPEN_CLOSE_AIRPORT);
 247 }