OpenTTD Source: src/station.cpp Source File

OpenTTD Source 1.11.0-RC1

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"
29 #include "linkgraph/linkgraphschedule.h"
30
31 #include "table/strings.h"
32
33 #include "safeguards.h"
34
36 StationPool _station_pool("Station");
37 INSTANTIATE_POOL_METHODS(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
86 Station::~Station()
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) {
118 LinkGraphSchedule::instance.Unqueue(lg);
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. */
141 InvalidateWindowClassesData(WC_STATION_LIST, 0);
142 } else {
143 InvalidateWindowData(WC_STATION_LIST, this->owner, 0);
144 }
145
146 DeleteWindowById(WC_STATION_VIEW, index);
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
158 CargoPacket::InvalidateAllFrom(this->index);
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 {
172 InvalidateWindowData(WC_SELECT_STATION, 0, 0);
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
292 if (_settings_game.station.modified_catchment) {
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
318 uint Station::GetCatchmentRadius() const
319 {
320 uint ret = CA_NONE;
321
322 if (_settings_game.station.modified_catchment) {
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
341 Rect Station::GetCatchmentRect() const
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
362 void Station::AddIndustryToDeliver(Industry *ind)
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
380 void Station::RemoveFromAllNearbyLists()
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 {
395 BitmapTileIterator it(this->catchment_tiles);
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
406 void Station::RecomputeCatchment()
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. */
418 this->catchment_tiles.Initialize(this->industry->location);
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
434 this->catchment_tiles.Initialize(GetCatchmentRect());
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 */
450 BitmapTileIterator it(this->catchment_tiles);
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
474 /* static */ void Station::RecomputeCatchmentForAll()
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
651 Money AirportMaintenanceCost(Owner owner)
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:44
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:78
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:571
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:3628
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:49
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:4666
StationSettings::serve_neutral_industries
bool serve_neutral_industries
company stations can serve industries with attached neutral stations
Definition: settings_type.h:532
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:536
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:46
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:367
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:83
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:454
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:531
news_func.h
roadveh.h
AXIS_X
@ AXIS_X
The X axis.
Definition: direction_type.h:124