OpenTTD Source  1.11.2
station.cpp
Go to the documentation of this file.
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 
10 #include "stdafx.h"
11 #include "company_func.h"
12 #include "company_base.h"
13 #include "roadveh.h"
14 #include "viewport_func.h"
15 #include "viewport_kdtree.h"
16 #include "date_func.h"
17 #include "command_func.h"
18 #include "news_func.h"
19 #include "aircraft.h"
20 #include "vehiclelist.h"
21 #include "core/pool_func.hpp"
22 #include "station_base.h"
23 #include "station_kdtree.h"
24 #include "roadstop_base.h"
25 #include "industry.h"
26 #include "town.h"
27 #include "core/random_func.hpp"
28 #include "linkgraph/linkgraph.h"
30 
31 #include "table/strings.h"
32 
33 #include "safeguards.h"
34 
36 StationPool _station_pool("Station");
38 
39 
40 StationKdtree _station_kdtree(Kdtree_StationXYFunc);
41 
42 void RebuildStationKdtree()
43 {
44  std::vector<StationID> stids;
45  for (const Station *st : Station::Iterate()) {
46  stids.push_back(st->index);
47  }
48  _station_kdtree.Build(stids.begin(), stids.end());
49 }
50 
51 
52 BaseStation::~BaseStation()
53 {
54  free(this->speclist);
55 
56  if (CleaningPool()) return;
57 
58  DeleteWindowById(WC_TRAINS_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_TRAIN, this->owner, this->index).Pack());
59  DeleteWindowById(WC_ROADVEH_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_ROAD, this->owner, this->index).Pack());
60  DeleteWindowById(WC_SHIPS_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_SHIP, this->owner, this->index).Pack());
61  DeleteWindowById(WC_AIRCRAFT_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_AIRCRAFT, this->owner, this->index).Pack());
62 
63  this->sign.MarkDirty();
64 }
65 
66 Station::Station(TileIndex tile) :
67  SpecializedStation<Station, false>(tile),
68  bus_station(INVALID_TILE, 0, 0),
69  truck_station(INVALID_TILE, 0, 0),
70  ship_station(INVALID_TILE, 0, 0),
71  indtype(IT_INVALID),
72  time_since_load(255),
73  time_since_unload(255),
74  last_vehicle_type(VEH_INVALID)
75 {
76  /* this->random_bits is set in Station::AddFacility() */
77 }
78 
87 {
88  if (CleaningPool()) {
89  for (CargoID c = 0; c < NUM_CARGO; c++) {
90  this->goods[c].cargo.OnCleanPool();
91  }
92  return;
93  }
94 
95  while (!this->loading_vehicles.empty()) {
96  this->loading_vehicles.front()->LeaveStation();
97  }
98 
99  for (Aircraft *a : Aircraft::Iterate()) {
100  if (!a->IsNormalAircraft()) continue;
101  if (a->targetairport == this->index) a->targetairport = INVALID_STATION;
102  }
103 
104  for (CargoID c = 0; c < NUM_CARGO; ++c) {
105  LinkGraph *lg = LinkGraph::GetIfValid(this->goods[c].link_graph);
106  if (lg == nullptr) continue;
107 
108  for (NodeID node = 0; node < lg->Size(); ++node) {
109  Station *st = Station::Get((*lg)[node].Station());
110  st->goods[c].flows.erase(this->index);
111  if ((*lg)[node][this->goods[c].node].LastUpdate() != INVALID_DATE) {
112  st->goods[c].flows.DeleteFlows(this->index);
113  RerouteCargo(st, c, this->index, st->index);
114  }
115  }
116  lg->RemoveNode(this->goods[c].node);
117  if (lg->Size() == 0) {
119  delete lg;
120  }
121  }
122 
123  for (Vehicle *v : Vehicle::Iterate()) {
124  /* Forget about this station if this station is removed */
125  if (v->last_station_visited == this->index) {
126  v->last_station_visited = INVALID_STATION;
127  }
128  if (v->last_loading_station == this->index) {
129  v->last_loading_station = INVALID_STATION;
130  }
131  }
132 
133  /* Remove station from industries and towns that reference it. */
134  this->RemoveFromAllNearbyLists();
135 
136  /* Clear the persistent storage. */
137  delete this->airport.psa;
138 
139  if (this->owner == OWNER_NONE) {
140  /* Invalidate all in case of oil rigs. */
142  } else {
144  }
145 
147 
148  /* Now delete all orders that go to the station */
149  RemoveOrderFromAllVehicles(OT_GOTO_STATION, this->index);
150 
151  /* Remove all news items */
152  DeleteStationNews(this->index);
153 
154  for (CargoID c = 0; c < NUM_CARGO; c++) {
155  this->goods[c].cargo.Truncate();
156  }
157 
159 
160  _station_kdtree.Remove(this->index);
161  if (this->sign.kdtree_valid) _viewport_sign_kdtree.Remove(ViewportSignKdtreeItem::MakeStation(this->index));
162 }
163 
164 
170 void BaseStation::PostDestructor(size_t index)
171 {
173 }
174 
180 RoadStop *Station::GetPrimaryRoadStop(const RoadVehicle *v) const
181 {
182  RoadStop *rs = this->GetPrimaryRoadStop(v->IsBus() ? ROADSTOP_BUS : ROADSTOP_TRUCK);
183 
184  for (; rs != nullptr; rs = rs->next) {
185  /* The vehicle cannot go to this roadstop (different roadtype) */
186  if (!HasTileAnyRoadType(rs->xy, v->compatible_roadtypes)) continue;
187  /* The vehicle is articulated and can therefore not go to a standard road stop. */
188  if (IsStandardRoadStopTile(rs->xy) && v->HasArticulatedPart()) continue;
189 
190  /* The vehicle can actually go to this road stop. So, return it! */
191  break;
192  }
193 
194  return rs;
195 }
196 
201 void Station::AddFacility(StationFacility new_facility_bit, TileIndex facil_xy)
202 {
203  if (this->facilities == FACIL_NONE) {
204  this->MoveSign(facil_xy);
205  this->random_bits = Random();
206  }
207  this->facilities |= new_facility_bit;
208  this->owner = _current_company;
209  this->build_date = _date;
210 }
211 
217 void Station::MarkTilesDirty(bool cargo_change) const
218 {
219  TileIndex tile = this->train_station.tile;
220  int w, h;
221 
222  if (tile == INVALID_TILE) return;
223 
224  /* cargo_change is set if we're refreshing the tiles due to cargo moving
225  * around. */
226  if (cargo_change) {
227  /* Don't waste time updating if there are no custom station graphics
228  * that might change. Even if there are custom graphics, they might
229  * not change. Unfortunately we have no way of telling. */
230  if (this->num_specs == 0) return;
231  }
232 
233  for (h = 0; h < train_station.h; h++) {
234  for (w = 0; w < train_station.w; w++) {
235  if (this->TileBelongsToRailStation(tile)) {
236  MarkTileDirtyByTile(tile);
237  }
238  tile += TileDiffXY(1, 0);
239  }
240  tile += TileDiffXY(-w, 1);
241  }
242 }
243 
244 /* virtual */ uint Station::GetPlatformLength(TileIndex tile) const
245 {
246  assert(this->TileBelongsToRailStation(tile));
247 
248  TileIndexDiff delta = (GetRailStationAxis(tile) == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
249 
250  TileIndex t = tile;
251  uint len = 0;
252  do {
253  t -= delta;
254  len++;
255  } while (IsCompatibleTrainStationTile(t, tile));
256 
257  t = tile;
258  do {
259  t += delta;
260  len++;
261  } while (IsCompatibleTrainStationTile(t, tile));
262 
263  return len - 1;
264 }
265 
266 /* virtual */ uint Station::GetPlatformLength(TileIndex tile, DiagDirection dir) const
267 {
268  TileIndex start_tile = tile;
269  uint length = 0;
270  assert(IsRailStationTile(tile));
271  assert(dir < DIAGDIR_END);
272 
273  do {
274  length++;
275  tile += TileOffsByDiagDir(dir);
276  } while (IsCompatibleTrainStationTile(tile, start_tile));
277 
278  return length;
279 }
280 
288 static uint GetTileCatchmentRadius(TileIndex tile, const Station *st)
289 {
290  assert(IsTileType(tile, MP_STATION));
291 
293  switch (GetStationType(tile)) {
294  case STATION_RAIL: return CA_TRAIN;
295  case STATION_OILRIG: return CA_UNMODIFIED;
296  case STATION_AIRPORT: return st->airport.GetSpec()->catchment;
297  case STATION_TRUCK: return CA_TRUCK;
298  case STATION_BUS: return CA_BUS;
299  case STATION_DOCK: return CA_DOCK;
300 
301  default: NOT_REACHED();
302  case STATION_BUOY:
303  case STATION_WAYPOINT: return CA_NONE;
304  }
305  } else {
306  switch (GetStationType(tile)) {
307  default: return CA_UNMODIFIED;
308  case STATION_BUOY:
309  case STATION_WAYPOINT: return CA_NONE;
310  }
311  }
312 }
313 
319 {
320  uint ret = CA_NONE;
321 
323  if (this->bus_stops != nullptr) ret = std::max<uint>(ret, CA_BUS);
324  if (this->truck_stops != nullptr) ret = std::max<uint>(ret, CA_TRUCK);
325  if (this->train_station.tile != INVALID_TILE) ret = std::max<uint>(ret, CA_TRAIN);
326  if (this->ship_station.tile != INVALID_TILE) ret = std::max<uint>(ret, CA_DOCK);
327  if (this->airport.tile != INVALID_TILE) ret = std::max<uint>(ret, this->airport.GetSpec()->catchment);
328  } else {
329  if (this->bus_stops != nullptr || this->truck_stops != nullptr || this->train_station.tile != INVALID_TILE || this->ship_station.tile != INVALID_TILE || this->airport.tile != INVALID_TILE) {
330  ret = CA_UNMODIFIED;
331  }
332  }
333 
334  return ret;
335 }
336 
342 {
343  assert(!this->rect.IsEmpty());
344 
345  /* Compute acceptance rectangle */
346  int catchment_radius = this->GetCatchmentRadius();
347 
348  Rect ret = {
349  std::max<int>(this->rect.left - catchment_radius, 0),
350  std::max<int>(this->rect.top - catchment_radius, 0),
351  std::min<int>(this->rect.right + catchment_radius, MapMaxX()),
352  std::min<int>(this->rect.bottom + catchment_radius, MapMaxY())
353  };
354 
355  return ret;
356 }
357 
363 {
364  /* Don't check further if this industry is already in the list */
365  if (this->industries_near.find(ind) != this->industries_near.end()) return;
366 
367  /* Include only industries that can accept cargo */
368  uint cargo_index;
369  for (cargo_index = 0; cargo_index < lengthof(ind->accepts_cargo); cargo_index++) {
370  if (ind->accepts_cargo[cargo_index] != CT_INVALID) break;
371  }
372  if (cargo_index >= lengthof(ind->accepts_cargo)) return;
373 
374  this->industries_near.insert(ind);
375 }
376 
381 {
382  for (Town *t : Town::Iterate()) { t->stations_near.erase(this); }
383  for (Industry *i : Industry::Iterate()) { i->stations_near.erase(this); }
384 }
385 
393 bool Station::CatchmentCoversTown(TownID t) const
394 {
396  for (TileIndex tile = it; tile != INVALID_TILE; tile = ++it) {
397  if (IsTileType(tile, MP_HOUSE) && GetTownIndex(tile) == t) return true;
398  }
399  return false;
400 }
401 
407 {
408  this->industries_near.clear();
409  this->RemoveFromAllNearbyLists();
410 
411  if (this->rect.IsEmpty()) {
412  this->catchment_tiles.Reset();
413  return;
414  }
415 
416  if (!_settings_game.station.serve_neutral_industries && this->industry != nullptr) {
417  /* Station is associated with an industry, so we only need to deliver to that industry. */
419  TILE_AREA_LOOP(tile, this->industry->location) {
420  if (IsTileType(tile, MP_INDUSTRY) && GetIndustryIndex(tile) == this->industry->index) {
421  this->catchment_tiles.SetTile(tile);
422  }
423  }
424  /* The industry's stations_near may have been computed before its neutral station was built so clear and re-add here. */
425  for (Station *st : this->industry->stations_near) {
426  st->industries_near.erase(this->industry);
427  }
428  this->industry->stations_near.clear();
429  this->industry->stations_near.insert(this);
430  this->industries_near.insert(this->industry);
431  return;
432  }
433 
435 
436  /* Loop finding all station tiles */
437  TileArea ta(TileXY(this->rect.left, this->rect.top), TileXY(this->rect.right, this->rect.bottom));
438  TILE_AREA_LOOP(tile, ta) {
439  if (!IsTileType(tile, MP_STATION) || GetStationIndex(tile) != this->index) continue;
440 
441  uint r = GetTileCatchmentRadius(tile, this);
442  if (r == CA_NONE) continue;
443 
444  /* This tile sub-loop doesn't need to test any tiles, they are simply added to the catchment set. */
445  TileArea ta2 = TileArea(tile, 1, 1).Expand(r);
446  TILE_AREA_LOOP(tile2, ta2) this->catchment_tiles.SetTile(tile2);
447  }
448 
449  /* Search catchment tiles for towns and industries */
451  for (TileIndex tile = it; tile != INVALID_TILE; tile = ++it) {
452  if (IsTileType(tile, MP_HOUSE)) {
453  Town *t = Town::GetByTile(tile);
454  t->stations_near.insert(this);
455  }
456  if (IsTileType(tile, MP_INDUSTRY)) {
457  Industry *i = Industry::GetByTile(tile);
458 
459  /* Ignore industry if it has a neutral station. It already can't be this station. */
460  if (!_settings_game.station.serve_neutral_industries && i->neutral_station != nullptr) continue;
461 
462  i->stations_near.insert(this);
463 
464  /* Add if we can deliver to this industry as well */
465  this->AddIndustryToDeliver(i);
466  }
467  }
468 }
469 
475 {
476  for (Station *st : Station::Iterate()) { st->RecomputeCatchment(); }
477 }
478 
479 /************************************************************************/
480 /* StationRect implementation */
481 /************************************************************************/
482 
483 StationRect::StationRect()
484 {
485  this->MakeEmpty();
486 }
487 
488 void StationRect::MakeEmpty()
489 {
490  this->left = this->top = this->right = this->bottom = 0;
491 }
492 
502 bool StationRect::PtInExtendedRect(int x, int y, int distance) const
503 {
504  return this->left - distance <= x && x <= this->right + distance &&
505  this->top - distance <= y && y <= this->bottom + distance;
506 }
507 
508 bool StationRect::IsEmpty() const
509 {
510  return this->left == 0 || this->left > this->right || this->top > this->bottom;
511 }
512 
513 CommandCost StationRect::BeforeAddTile(TileIndex tile, StationRectMode mode)
514 {
515  int x = TileX(tile);
516  int y = TileY(tile);
517  if (this->IsEmpty()) {
518  /* we are adding the first station tile */
519  if (mode != ADD_TEST) {
520  this->left = this->right = x;
521  this->top = this->bottom = y;
522  }
523  } else if (!this->PtInExtendedRect(x, y)) {
524  /* current rect is not empty and new point is outside this rect
525  * make new spread-out rectangle */
526  Rect new_rect = {std::min(x, this->left), std::min(y, this->top), std::max(x, this->right), std::max(y, this->bottom)};
527 
528  /* check new rect dimensions against preset max */
529  int w = new_rect.right - new_rect.left + 1;
530  int h = new_rect.bottom - new_rect.top + 1;
531  if (mode != ADD_FORCE && (w > _settings_game.station.station_spread || h > _settings_game.station.station_spread)) {
532  assert(mode != ADD_TRY);
533  return_cmd_error(STR_ERROR_STATION_TOO_SPREAD_OUT);
534  }
535 
536  /* spread-out ok, return true */
537  if (mode != ADD_TEST) {
538  /* we should update the station rect */
539  *this = new_rect;
540  }
541  } else {
542  ; // new point is inside the rect, we don't need to do anything
543  }
544  return CommandCost();
545 }
546 
547 CommandCost StationRect::BeforeAddRect(TileIndex tile, int w, int h, StationRectMode mode)
548 {
549  if (mode == ADD_FORCE || (w <= _settings_game.station.station_spread && h <= _settings_game.station.station_spread)) {
550  /* Important when the old rect is completely inside the new rect, resp. the old one was empty. */
551  CommandCost ret = this->BeforeAddTile(tile, mode);
552  if (ret.Succeeded()) ret = this->BeforeAddTile(TILE_ADDXY(tile, w - 1, h - 1), mode);
553  return ret;
554  }
555  return CommandCost();
556 }
557 
567 /* static */ bool StationRect::ScanForStationTiles(StationID st_id, int left_a, int top_a, int right_a, int bottom_a)
568 {
569  TileArea ta(TileXY(left_a, top_a), TileXY(right_a, bottom_a));
570  TILE_AREA_LOOP(tile, ta) {
571  if (IsTileType(tile, MP_STATION) && GetStationIndex(tile) == st_id) return true;
572  }
573 
574  return false;
575 }
576 
577 bool StationRect::AfterRemoveTile(BaseStation *st, TileIndex tile)
578 {
579  int x = TileX(tile);
580  int y = TileY(tile);
581 
582  /* look if removed tile was on the bounding rect edge
583  * and try to reduce the rect by this edge
584  * do it until we have empty rect or nothing to do */
585  for (;;) {
586  /* check if removed tile is on rect edge */
587  bool left_edge = (x == this->left);
588  bool right_edge = (x == this->right);
589  bool top_edge = (y == this->top);
590  bool bottom_edge = (y == this->bottom);
591 
592  /* can we reduce the rect in either direction? */
593  bool reduce_x = ((left_edge || right_edge) && !ScanForStationTiles(st->index, x, this->top, x, this->bottom));
594  bool reduce_y = ((top_edge || bottom_edge) && !ScanForStationTiles(st->index, this->left, y, this->right, y));
595  if (!(reduce_x || reduce_y)) break; // nothing to do (can't reduce)
596 
597  if (reduce_x) {
598  /* reduce horizontally */
599  if (left_edge) {
600  /* move left edge right */
601  this->left = x = x + 1;
602  } else {
603  /* move right edge left */
604  this->right = x = x - 1;
605  }
606  }
607  if (reduce_y) {
608  /* reduce vertically */
609  if (top_edge) {
610  /* move top edge down */
611  this->top = y = y + 1;
612  } else {
613  /* move bottom edge up */
614  this->bottom = y = y - 1;
615  }
616  }
617 
618  if (left > right || top > bottom) {
619  /* can't continue, if the remaining rectangle is empty */
620  this->MakeEmpty();
621  return true; // empty remaining rect
622  }
623  }
624  return false; // non-empty remaining rect
625 }
626 
627 bool StationRect::AfterRemoveRect(BaseStation *st, TileArea ta)
628 {
629  assert(this->PtInExtendedRect(TileX(ta.tile), TileY(ta.tile)));
630  assert(this->PtInExtendedRect(TileX(ta.tile) + ta.w - 1, TileY(ta.tile) + ta.h - 1));
631 
632  bool empty = this->AfterRemoveTile(st, ta.tile);
633  if (ta.w != 1 || ta.h != 1) empty = empty || this->AfterRemoveTile(st, TILE_ADDXY(ta.tile, ta.w - 1, ta.h - 1));
634  return empty;
635 }
636 
637 StationRect& StationRect::operator = (const Rect &src)
638 {
639  this->left = src.left;
640  this->top = src.top;
641  this->right = src.right;
642  this->bottom = src.bottom;
643  return *this;
644 }
645 
652 {
653  Money total_cost = 0;
654 
655  for (const Station *st : Station::Iterate()) {
656  if (st->owner == owner && (st->facilities & FACIL_AIRPORT)) {
657  total_cost += _price[PR_INFRASTRUCTURE_AIRPORT] * st->airport.GetSpec()->maintenance_cost;
658  }
659  }
660  /* 3 bits fraction for the maintenance cost factor. */
661  return total_cost >> 3;
662 }
663 
664 bool StationCompare::operator() (const Station *lhs, const Station *rhs) const
665 {
666  return lhs->index < rhs->index;
667 }
VEH_AIRCRAFT
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
RoadVehicle
Buses, trucks and trams belong to this class.
Definition: roadveh.h:107
MP_HOUSE
@ MP_HOUSE
A house by a town.
Definition: tile_type.h:49
BaseStation::facilities
StationFacility facilities
The facilities that this station has.
Definition: base_station_base.h:63
CA_UNMODIFIED
@ CA_UNMODIFIED
Catchment for all stations with "modified catchment" disabled.
Definition: station_type.h:82
WC_ROADVEH_LIST
@ WC_ROADVEH_LIST
Road vehicle list; Window numbers:
Definition: window_type.h:307
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:83
InvalidateWindowData
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
Definition: window.cpp:3321
Station::goods
GoodsEntry goods[NUM_CARGO]
Goods at this station.
Definition: station_base.h:479
HasTileAnyRoadType
static bool HasTileAnyRoadType(TileIndex t, RoadTypes rts)
Check if a tile has one of the specified road types.
Definition: road_map.h:221
StationRect
StationRect - used to track station spread out rectangle - cheaper than scanning whole map.
Definition: base_station_base.h:29
station_kdtree.h
TileOffsByDiagDir
static TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition: map_func.h:341
GameSettings::station
StationSettings station
settings related to station management
Definition: settings_type.h:575
BitmapTileArea::Initialize
void Initialize(const Rect &r)
Initialize the BitmapTileArea with the specified Rect.
Definition: bitmap_type.h:58
CargoList::OnCleanPool
void OnCleanPool()
Empty the cargo list, but don't free the cargo packets; the cargo packets are cleaned by CargoPacket'...
Definition: cargopacket.cpp:167
LinkGraph
A connected component of a link graph.
Definition: linkgraph.h:39
Station::GetPlatformLength
uint GetPlatformLength(TileIndex tile, DiagDirection dir) const override
Determines the REMAINING length of a platform, starting at (and including) the given tile.
Definition: station.cpp:266
command_func.h
RerouteCargo
void RerouteCargo(Station *st, CargoID c, StationID avoid, StationID avoid2)
Reroute cargo of type c at station st or in any vehicles unloading there.
Definition: station_cmd.cpp:3627
Pool::PoolItem<&_link_graph_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:340
CA_NONE
@ CA_NONE
Catchment when the station has no facilities.
Definition: station_type.h:76
Kdtree
K-dimensional tree, specialised for 2-dimensional space.
Definition: kdtree.hpp:37
VehicleListIdentifier
The information about a vehicle list.
Definition: vehiclelist.h:29
BitmapTileArea::SetTile
void SetTile(TileIndex tile)
Add a tile as part of the tile area.
Definition: bitmap_type.h:80
company_base.h
RoadStop::xy
TileIndex xy
Position on the map.
Definition: roadstop_base.h:67
Station
Station data structure.
Definition: station_base.h:450
Station::RecomputeCatchment
void RecomputeCatchment()
Recompute tiles covered in our catchment area.
Definition: station.cpp:406
CargoPacket::InvalidateAllFrom
static void InvalidateAllFrom(SourceType src_type, SourceID src)
Invalidates (sets source_id to INVALID_SOURCE) all cargo packets from given source.
Definition: cargopacket.cpp:127
SpecializedStation
Class defining several overloaded accessors so we don't have to cast base stations that often.
Definition: base_station_base.h:182
_station_pool
StationPool _station_pool("Station")
The pool of stations.
DeleteStationNews
void DeleteStationNews(StationID sid)
Remove news regarding given station so there are no 'unknown station now accepts Mail' or 'First trai...
Definition: news_gui.cpp:921
vehiclelist.h
BitmapTileIterator
Iterator to iterate over all tiles belonging to a bitmaptilearea.
Definition: bitmap_type.h:107
LinkGraphSchedule::instance
static LinkGraphSchedule instance
Static instance of LinkGraphSchedule.
Definition: linkgraphschedule.h:52
DIAGDIR_END
@ DIAGDIR_END
Used for iterations.
Definition: direction_type.h:83
Pool::PoolItem<&_station_pool >::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:227
StationRect::PtInExtendedRect
bool PtInExtendedRect(int x, int y, int distance=0) const
Determines whether a given point (x, y) is within a certain distance of the station rectangle.
Definition: station.cpp:502
IsCompatibleTrainStationTile
static bool IsCompatibleTrainStationTile(TileIndex test_tile, TileIndex station_tile)
Check if a tile is a valid continuation to a railstation tile.
Definition: station_map.h:378
Station::MoveSign
void MoveSign(TileIndex new_xy) override
Move the station main coordinate somewhere else.
Definition: station_cmd.cpp:435
IsStandardRoadStopTile
static bool IsStandardRoadStopTile(TileIndex t)
Is tile t a standard (non-drive through) road stop station?
Definition: station_map.h:223
aircraft.h
FACIL_NONE
@ FACIL_NONE
The station has no facilities at all.
Definition: station_type.h:51
SpecializedStation< Station, false >::Get
static Station * Get(size_t index)
Gets station with given index.
Definition: base_station_base.h:219
MP_INDUSTRY
@ MP_INDUSTRY
Part of an industry.
Definition: tile_type.h:54
town.h
TileY
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
GetTileCatchmentRadius
static uint GetTileCatchmentRadius(TileIndex tile, const Station *st)
Get the catchment size of an individual station tile.
Definition: station.cpp:288
WC_STATION_VIEW
@ WC_STATION_VIEW
Station view; Window numbers:
Definition: window_type.h:338
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:222
Industry
Defines the internal data of a functional industry.
Definition: industry.h:66
Station::CatchmentCoversTown
bool CatchmentCoversTown(TownID t) const
Test if the given town ID is covered by our catchment area.
Definition: station.cpp:393
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
LinkGraph::RemoveNode
void RemoveNode(NodeID id)
Remove a node from the link graph by overwriting it with the last node.
Definition: linkgraph.cpp:119
Kdtree::Build
void Build(It begin, It end)
Clear and rebuild the tree from a new sequence of elements,.
Definition: kdtree.hpp:364
BaseStation::owner
Owner owner
The owner of this station.
Definition: base_station_base.h:62
GetTownIndex
static TownID GetTownIndex(TileIndex t)
Get the index of which town this house/street is attached to.
Definition: town_map.h:22
Industry::neutral_station
Station * neutral_station
Associated neutral station.
Definition: industry.h:69
CommandCost::Succeeded
bool Succeeded() const
Did this command succeed?
Definition: command_type.h:150
BaseStation::num_specs
uint8 num_specs
Number of specs in the speclist.
Definition: base_station_base.h:65
TileX
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
Kdtree::Remove
void Remove(const T &element)
Remove a single element from the tree, if it exists.
Definition: kdtree.hpp:419
SpecializedStation< Station, false >::Iterate
static Pool::IterateWrapper< Station > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
Definition: base_station_base.h:270
ROADSTOP_BUS
@ ROADSTOP_BUS
A standard stop for buses.
Definition: station_type.h:45
Aircraft
Aircraft, helicopters, rotors and their shadows belong to this class.
Definition: aircraft.h:74
GoodsEntry::cargo
StationCargoList cargo
The cargo packets of cargo waiting in this station.
Definition: station_base.h:255
RoadStop::next
struct RoadStop * next
Next stop of the given type at this station.
Definition: roadstop_base.h:69
FlowStatMap::DeleteFlows
StationIDStack DeleteFlows(StationID via)
Delete all flows at a station for specific cargo and destination.
Definition: station_cmd.cpp:4665
StationSettings::serve_neutral_industries
bool serve_neutral_industries
company stations can serve industries with attached neutral stations
Definition: settings_type.h:536
return_cmd_error
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
Definition: command_func.h:33
BaseStation::sign
TrackedViewportSign sign
NOSAVE: Dimensions of sign.
Definition: base_station_base.h:54
Industry::stations_near
StationList stations_near
NOSAVE: List of nearby stations.
Definition: industry.h:91
CommandCost
Common return value for all commands.
Definition: command_type.h:23
Industry::location
TileArea location
Location of the industry.
Definition: industry.h:67
_date
Date _date
Current date in days (day counter)
Definition: date.cpp:28
TILE_AREA_LOOP
#define TILE_AREA_LOOP(var, ta)
A loop which iterates over the tiles of a TileArea.
Definition: tilearea_type.h:232
BaseStation::train_station
TileArea train_station
Tile area the train 'station' part covers.
Definition: base_station_base.h:75
Industry::GetByTile
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition: industry.h:144
Station::RecomputeCatchmentForAll
static void RecomputeCatchmentForAll()
Recomputes catchment of all stations.
Definition: station.cpp:474
BaseStation::random_bits
uint16 random_bits
Random bits assigned to this station.
Definition: base_station_base.h:70
roadstop_base.h
BaseStation::rect
StationRect rect
NOSAVE: Station spread out rectangle maintained by StationRect::xxx() functions.
Definition: base_station_base.h:76
TileIndexDiff
int32 TileIndexDiff
An offset value between to tiles.
Definition: map_func.h:154
Station::MarkTilesDirty
void MarkTilesDirty(bool cargo_change) const
Marks the tiles of the station as dirty.
Definition: station.cpp:217
BitmapTileArea::Reset
void Reset()
Reset and clear the BitmapTileArea.
Definition: bitmap_type.h:46
OrthogonalTileArea::w
uint16 w
The width of the area.
Definition: tilearea_type.h:18
Town::stations_near
StationList stations_near
NOSAVE: List of nearby stations.
Definition: town.h:83
GetStationType
static StationType GetStationType(TileIndex t)
Get the station type of this tile.
Definition: station_map.h:44
Station::airport
Airport airport
Tile area the airport covers.
Definition: station_base.h:464
OrthogonalTileArea
Represents the covered area of e.g.
Definition: tilearea_type.h:16
LinkGraph::Size
uint Size() const
Get the current size of the component.
Definition: linkgraph.h:498
Station::AddFacility
void AddFacility(StationFacility new_facility_bit, TileIndex facil_xy)
Called when new facility is built on the station.
Definition: station.cpp:201
Station::TileBelongsToRailStation
bool TileBelongsToRailStation(TileIndex tile) const override
Check whether a specific tile belongs to this station.
Definition: station_base.h:514
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:80
ViewportSign::MarkDirty
void MarkDirty(ZoomLevel maxzoom=ZOOM_LVL_MAX) const
Mark the sign dirty in all viewports.
Definition: viewport.cpp:1466
Station::~Station
~Station()
Clean up a station by clearing vehicle orders, invalidating windows and removing link stats.
Definition: station.cpp:86
Station::AddIndustryToDeliver
void AddIndustryToDeliver(Industry *ind)
Add nearby industry to station's industries_near list if it accepts cargo.
Definition: station.cpp:362
industry.h
safeguards.h
CA_BUS
@ CA_BUS
Catchment for bus stops with "modified catchment" enabled.
Definition: station_type.h:77
VEH_INVALID
@ VEH_INVALID
Non-existing type of vehicle.
Definition: vehicle_type.h:35
WC_SHIPS_LIST
@ WC_SHIPS_LIST
Ships list; Window numbers:
Definition: window_type.h:313
ROADSTOP_TRUCK
@ ROADSTOP_TRUCK
A standard stop for trucks.
Definition: station_type.h:46
RoadVehicle::compatible_roadtypes
RoadTypes compatible_roadtypes
Roadtypes this consist is powered on.
Definition: roadveh.h:118
AirportMaintenanceCost
Money AirportMaintenanceCost(Owner owner)
Calculates the maintenance cost of all airports of a company.
Definition: station.cpp:651
CA_TRUCK
@ CA_TRUCK
Catchment for truck stops with "modified catchment" enabled.
Definition: station_type.h:78
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition: direction_type.h:77
WC_TRAINS_LIST
@ WC_TRAINS_LIST
Trains list; Window numbers:
Definition: window_type.h:301
StationSettings::station_spread
byte station_spread
amount a station may spread
Definition: settings_type.h:540
date_func.h
IsRailStationTile
static bool IsRailStationTile(TileIndex t)
Is this tile a station tile and a rail station?
Definition: station_map.h:102
linkgraphschedule.h
stdafx.h
Station::truck_stops
RoadStop * truck_stops
All the truck stops.
Definition: station_base.h:461
Station::industry
Industry * industry
NOSAVE: Associated industry for neutral stations. (Rebuilt on load from Industry->st)
Definition: station_base.h:483
viewport_func.h
StationRect::ScanForStationTiles
static bool ScanForStationTiles(StationID st_id, int left_a, int top_a, int right_a, int bottom_a)
Check whether station tiles of the given station id exist in the given rectangle.
Definition: station.cpp:567
IsTileType
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
StationFacility
StationFacility
The facilities a station might be having.
Definition: station_type.h:50
OrthogonalTileArea::h
uint16 h
The height of the area.
Definition: tilearea_type.h:19
CA_DOCK
@ CA_DOCK
Catchment for docks with "modified catchment" enabled.
Definition: station_type.h:80
Station::industries_near
IndustryList industries_near
Cached list of industries near the station that can accept cargo,.
Definition: station_base.h:482
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
WC_SELECT_STATION
@ WC_SELECT_STATION
Select station (when joining stations); Window numbers:
Definition: window_type.h:235
station_base.h
Pool::PoolItem<&_vehicle_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:378
Pool
Base class for all pools.
Definition: pool_type.hpp:81
DeleteWindowById
void DeleteWindowById(WindowClass cls, WindowNumber number, bool force)
Delete a window by its class and window number (if it is open).
Definition: window.cpp:1165
MapMaxY
static uint MapMaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition: map_func.h:111
TileXY
static TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition: map_func.h:163
INVALID_DATE
static const Date INVALID_DATE
Representation of an invalid date.
Definition: date_type.h:110
GetRailStationAxis
static Axis GetRailStationAxis(TileIndex t)
Get the rail direction of a rail station.
Definition: station_map.h:337
GoodsEntry::flows
FlowStatMap flows
Planned flows through this station.
Definition: station_base.h:259
Station::GetCatchmentRadius
uint GetCatchmentRadius() const
Determines the catchment radius of the station.
Definition: station.cpp:318
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition: tilearea_type.h:17
RemoveOrderFromAllVehicles
void RemoveOrderFromAllVehicles(OrderType type, DestinationID destination, bool hangar)
Removes an order from all vehicles.
Definition: order_cmd.cpp:1805
InvalidateWindowClassesData
void InvalidateWindowClassesData(WindowClass cls, int data, bool gui_scope)
Mark window data of all windows of a given class as invalid (in need of re-computing) Note that by de...
Definition: window.cpp:3339
GetIndustryIndex
static IndustryID GetIndustryIndex(TileIndex t)
Get the industry ID of the given tile.
Definition: industry_map.h:63
Pool::PoolItem<&_station_pool >::CleaningPool
static bool CleaningPool()
Returns current state of pool cleaning - yes or no.
Definition: pool_type.hpp:308
MarkTileDirtyByTile
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
Definition: viewport.cpp:1985
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition: company_type.h:25
TileDiffXY
static TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition: map_func.h:179
MP_STATION
@ MP_STATION
A tile of a station.
Definition: tile_type.h:51
NUM_CARGO
@ NUM_CARGO
Maximal number of cargo types in a game.
Definition: cargo_type.h:64
GetStationIndex
static StationID GetStationIndex(TileIndex t)
Get StationID from a tile.
Definition: station_map.h:28
Vehicle::HasArticulatedPart
bool HasArticulatedPart() const
Check if an engine has an articulated part.
Definition: vehicle_base.h:913
TrackedViewportSign::kdtree_valid
bool kdtree_valid
Are the sign data valid for use with the _viewport_sign_kdtree?
Definition: viewport_type.h:58
Station::GetCatchmentRect
Rect GetCatchmentRect() const
Determines catchment rectangle of this station.
Definition: station.cpp:341
linkgraph.h
Station::catchment_tiles
BitmapTileArea catchment_tiles
NOSAVE: Set of individual tiles covered by catchment area.
Definition: station_base.h:470
BaseStation
Base class for all station-ish types.
Definition: base_station_base.h:52
company_func.h
SpecializedVehicle< Aircraft, VEH_AIRCRAFT >::Iterate
static Pool::IterateWrapper< Aircraft > Iterate(size_t from=0)
Returns an iterable ensemble of all valid vehicles of type T.
Definition: vehicle_base.h:1231
MapMaxX
static uint MapMaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:102
INSTANTIATE_POOL_METHODS
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
Definition: pool_func.hpp:224
TILE_ADDXY
#define TILE_ADDXY(tile, x, y)
Adds a given offset to a tile.
Definition: map_func.h:258
TileArea
OrthogonalTileArea TileArea
Shorthand for the much more common orthogonal tile area.
Definition: tilearea_type.h:96
BaseStation::speclist
StationSpecList * speclist
List of station specs of this station.
Definition: base_station_base.h:66
Town
Town data structure.
Definition: town.h:50
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:369
Station::RemoveFromAllNearbyLists
void RemoveFromAllNearbyLists()
Remove this station from the nearby stations lists of all towns and industries.
Definition: station.cpp:380
BaseStation::PostDestructor
static void PostDestructor(size_t index)
Invalidating of the JoinStation window has to be done after removing item from the pool.
Definition: station.cpp:170
CA_TRAIN
@ CA_TRAIN
Catchment for train stations with "modified catchment" enabled.
Definition: station_type.h:79
random_func.hpp
OverflowSafeInt< int64, INT64_MAX, INT64_MIN >
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
INVALID_TILE
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:88
RoadVehicle::IsBus
bool IsBus() const
Check whether a roadvehicle is a bus.
Definition: roadveh_cmd.cpp:79
OrthogonalTileArea::Expand
OrthogonalTileArea & Expand(int rad)
Expand a tile area by rad tiles in each direction, keeping within map bounds.
Definition: tilearea.cpp:123
Station::bus_stops
RoadStop * bus_stops
All the road stops.
Definition: station_base.h:459
LinkGraphSchedule::Unqueue
void Unqueue(LinkGraph *lg)
Remove a link graph from the execution queue.
Definition: linkgraphschedule.h:77
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
Industry::accepts_cargo
CargoID accepts_cargo[INDUSTRY_NUM_INPUTS]
16 input cargo slots
Definition: industry.h:75
RoadStop
A Stop for a Road Vehicle.
Definition: roadstop_base.h:22
FACIL_AIRPORT
@ FACIL_AIRPORT
Station with an airport.
Definition: station_type.h:55
Airport::psa
PersistentStorage * psa
Persistent storage for NewGRF airports.
Definition: station_base.h:313
Airport::GetSpec
const AirportSpec * GetSpec() const
Get the AirportSpec that from the airport type of this airport.
Definition: station_base.h:320
pool_func.hpp
free
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: stdafx.h:456
CT_INVALID
@ CT_INVALID
Invalid cargo type.
Definition: cargo_type.h:68
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
Rect
Specification of a rectangle with absolute coordinates of all edges.
Definition: geometry_type.hpp:47
WC_AIRCRAFT_LIST
@ WC_AIRCRAFT_LIST
Aircraft list; Window numbers:
Definition: window_type.h:319
BaseStation::build_date
Date build_date
Date of construction.
Definition: base_station_base.h:68
WC_STATION_LIST
@ WC_STATION_LIST
Station list; Window numbers:
Definition: window_type.h:295
AirportSpec::catchment
byte catchment
catchment area of this airport
Definition: newgrf_airport.h:108
StationCargoList::Truncate
uint Truncate(uint max_move=UINT_MAX, StationCargoAmountMap *cargo_per_source=nullptr)
Truncates where each destination loses roughly the same percentage of its cargo.
Definition: cargopacket.cpp:769
Station::ship_station
TileArea ship_station
Tile area the ship 'station' part covers.
Definition: station_base.h:465
StationSettings::modified_catchment
bool modified_catchment
different-size catchment areas
Definition: settings_type.h:535
news_func.h
roadveh.h
AXIS_X
@ AXIS_X
The X axis.
Definition: direction_type.h:124