OpenTTD Source: src/station.cpp Source File

OpenTTD Source 13.1

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 if (CleaningPool()) return;
55
56 CloseWindowById(WC_TRAINS_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_TRAIN, this->owner, this->index).Pack());
57 CloseWindowById(WC_ROADVEH_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_ROAD, this->owner, this->index).Pack());
58 CloseWindowById(WC_SHIPS_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_SHIP, this->owner, this->index).Pack());
59 CloseWindowById(WC_AIRCRAFT_LIST, VehicleListIdentifier(VL_STATION_LIST, VEH_AIRCRAFT, this->owner, this->index).Pack());
60
61 this->sign.MarkDirty();
62 }
63
64 Station::Station(TileIndex tile) :
65 SpecializedStation<Station, false>(tile),
66 bus_station(INVALID_TILE, 0, 0),
67 truck_station(INVALID_TILE, 0, 0),
68 ship_station(INVALID_TILE, 0, 0),
69 indtype(IT_INVALID),
70 time_since_load(255),
71 time_since_unload(255),
72 last_vehicle_type(VEH_INVALID)
73 {
74 /* this->random_bits is set in Station::AddFacility() */
75 }
76
84 Station::~Station()
85 {
86 if (CleaningPool()) {
87 for (CargoID c = 0; c < NUM_CARGO; c++) {
88 this->goods[c].cargo.OnCleanPool();
89 }
90 return;
91 }
92
93 while (!this->loading_vehicles.empty()) {
94 this->loading_vehicles.front()->LeaveStation();
95 }
96
97 for (Aircraft *a : Aircraft::Iterate()) {
98 if (!a->IsNormalAircraft()) continue;
99 if (a->targetairport == this->index) a->targetairport = INVALID_STATION;
100 }
101
102 for (CargoID c = 0; c < NUM_CARGO; ++c) {
103 LinkGraph *lg = LinkGraph::GetIfValid(this->goods[c].link_graph);
104 if (lg == nullptr) continue;
105
106 for (NodeID node = 0; node < lg->Size(); ++node) {
107 Station *st = Station::Get((*lg)[node].Station());
108 st->goods[c].flows.erase(this->index);
109 if ((*lg)[node][this->goods[c].node].LastUpdate() != INVALID_DATE) {
110 st->goods[c].flows.DeleteFlows(this->index);
111 RerouteCargo(st, c, this->index, st->index);
112 }
113 }
114 lg->RemoveNode(this->goods[c].node);
115 if (lg->Size() == 0) {
116 LinkGraphSchedule::instance.Unqueue(lg);
117 delete lg;
118 }
119 }
120
121 for (Vehicle *v : Vehicle::Iterate()) {
122 /* Forget about this station if this station is removed */
123 if (v->last_station_visited == this->index) {
124 v->last_station_visited = INVALID_STATION;
125 }
126 if (v->last_loading_station == this->index) {
127 v->last_loading_station = INVALID_STATION;
128 }
129 }
130
131 /* Remove station from industries and towns that reference it. */
132 this->RemoveFromAllNearbyLists();
133
134 /* Clear the persistent storage. */
135 delete this->airport.psa;
136
137 if (this->owner == OWNER_NONE) {
138 /* Invalidate all in case of oil rigs. */
139 InvalidateWindowClassesData(WC_STATION_LIST, 0);
140 } else {
141 InvalidateWindowData(WC_STATION_LIST, this->owner, 0);
142 }
143
144 CloseWindowById(WC_STATION_VIEW, index);
145
146 /* Now delete all orders that go to the station */
147 RemoveOrderFromAllVehicles(OT_GOTO_STATION, this->index);
148
149 /* Remove all news items */
150 DeleteStationNews(this->index);
151
152 for (CargoID c = 0; c < NUM_CARGO; c++) {
153 this->goods[c].cargo.Truncate();
154 }
155
156 CargoPacket::InvalidateAllFrom(this->index);
157
158 _station_kdtree.Remove(this->index);
159 if (this->sign.kdtree_valid) _viewport_sign_kdtree.Remove(ViewportSignKdtreeItem::MakeStation(this->index));
160 }
161
162
168 void BaseStation::PostDestructor(size_t index)
169 {
170 InvalidateWindowData(WC_SELECT_STATION, 0, 0);
171 }
172
178 RoadStop *Station::GetPrimaryRoadStop(const RoadVehicle *v) const
179 {
180 RoadStop *rs = this->GetPrimaryRoadStop(v->IsBus() ? ROADSTOP_BUS : ROADSTOP_TRUCK);
181
182 for (; rs != nullptr; rs = rs->next) {
183 /* The vehicle cannot go to this roadstop (different roadtype) */
184 if (!HasTileAnyRoadType(rs->xy, v->compatible_roadtypes)) continue;
185 /* The vehicle is articulated and can therefore not go to a standard road stop. */
186 if (IsStandardRoadStopTile(rs->xy) && v->HasArticulatedPart()) continue;
187
188 /* The vehicle can actually go to this road stop. So, return it! */
189 break;
190 }
191
192 return rs;
193 }
194
199 void Station::AddFacility(StationFacility new_facility_bit, TileIndex facil_xy)
200 {
201 if (this->facilities == FACIL_NONE) {
202 this->MoveSign(facil_xy);
203 this->random_bits = Random();
204 }
205 this->facilities |= new_facility_bit;
206 this->owner = _current_company;
207 this->build_date = _date;
208 }
209
215 void Station::MarkTilesDirty(bool cargo_change) const
216 {
217 TileIndex tile = this->train_station.tile;
218 int w, h;
219
220 if (tile == INVALID_TILE) return;
221
222 /* cargo_change is set if we're refreshing the tiles due to cargo moving
223 * around. */
224 if (cargo_change) {
225 /* Don't waste time updating if there are no custom station graphics
226 * that might change. Even if there are custom graphics, they might
227 * not change. Unfortunately we have no way of telling. */
228 if (this->speclist.size() == 0) return;
229 }
230
231 for (h = 0; h < train_station.h; h++) {
232 for (w = 0; w < train_station.w; w++) {
233 if (this->TileBelongsToRailStation(tile)) {
234 MarkTileDirtyByTile(tile);
235 }
236 tile += TileDiffXY(1, 0);
237 }
238 tile += TileDiffXY(-w, 1);
239 }
240 }
241
242 /* virtual */ uint Station::GetPlatformLength(TileIndex tile) const
243 {
244 assert(this->TileBelongsToRailStation(tile));
245
246 TileIndexDiff delta = (GetRailStationAxis(tile) == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
247
248 TileIndex t = tile;
249 uint len = 0;
250 do {
251 t -= delta;
252 len++;
253 } while (IsCompatibleTrainStationTile(t, tile));
254
255 t = tile;
256 do {
257 t += delta;
258 len++;
259 } while (IsCompatibleTrainStationTile(t, tile));
260
261 return len - 1;
262 }
263
264 /* virtual */ uint Station::GetPlatformLength(TileIndex tile, DiagDirection dir) const
265 {
266 TileIndex start_tile = tile;
267 uint length = 0;
268 assert(IsRailStationTile(tile));
269 assert(dir < DIAGDIR_END);
270
271 do {
272 length++;
273 tile += TileOffsByDiagDir(dir);
274 } while (IsCompatibleTrainStationTile(tile, start_tile));
275
276 return length;
277 }
278
286 static uint GetTileCatchmentRadius(TileIndex tile, const Station *st)
287 {
288 assert(IsTileType(tile, MP_STATION));
289
290 if (_settings_game.station.modified_catchment) {
291 switch (GetStationType(tile)) {
292 case STATION_RAIL: return CA_TRAIN;
293 case STATION_OILRIG: return CA_UNMODIFIED;
294 case STATION_AIRPORT: return st->airport.GetSpec()->catchment;
295 case STATION_TRUCK: return CA_TRUCK;
296 case STATION_BUS: return CA_BUS;
297 case STATION_DOCK: return CA_DOCK;
298
299 default: NOT_REACHED();
300 case STATION_BUOY:
301 case STATION_WAYPOINT: return CA_NONE;
302 }
303 } else {
304 switch (GetStationType(tile)) {
305 default: return CA_UNMODIFIED;
306 case STATION_BUOY:
307 case STATION_WAYPOINT: return CA_NONE;
308 }
309 }
310 }
311
316 uint Station::GetCatchmentRadius() const
317 {
318 uint ret = CA_NONE;
319
320 if (_settings_game.station.modified_catchment) {
321 if (this->bus_stops != nullptr) ret = std::max<uint>(ret, CA_BUS);
322 if (this->truck_stops != nullptr) ret = std::max<uint>(ret, CA_TRUCK);
323 if (this->train_station.tile != INVALID_TILE) ret = std::max<uint>(ret, CA_TRAIN);
324 if (this->ship_station.tile != INVALID_TILE) ret = std::max<uint>(ret, CA_DOCK);
325 if (this->airport.tile != INVALID_TILE) ret = std::max<uint>(ret, this->airport.GetSpec()->catchment);
326 } else {
327 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) {
328 ret = CA_UNMODIFIED;
329 }
330 }
331
332 return ret;
333 }
334
339 Rect Station::GetCatchmentRect() const
340 {
341 assert(!this->rect.IsEmpty());
342
343 /* Compute acceptance rectangle */
344 int catchment_radius = this->GetCatchmentRadius();
345
346 Rect ret = {
347 std::max<int>(this->rect.left - catchment_radius, 0),
348 std::max<int>(this->rect.top - catchment_radius, 0),
349 std::min<int>(this->rect.right + catchment_radius, MapMaxX()),
350 std::min<int>(this->rect.bottom + catchment_radius, MapMaxY())
351 };
352
353 return ret;
354 }
355
362 void Station::AddIndustryToDeliver(Industry *ind, TileIndex tile)
363 {
364 /* Using DistanceMax to get about the same order as with previously used CircularTileSearch. */
365 uint distance = DistanceMax(this->xy, tile);
366
367 /* Don't check further if this industry is already in the list but update the distance if it's closer */
368 auto pos = std::find_if(this->industries_near.begin(), this->industries_near.end(), [&](const IndustryListEntry &e) { return e.industry->index == ind->index; });
369 if (pos != this->industries_near.end()) {
370 if (pos->distance > distance) {
371 auto node = this->industries_near.extract(pos);
372 node.value().distance = distance;
373 this->industries_near.insert(std::move(node));
374 }
375 return;
376 }
377
378 /* Include only industries that can accept cargo */
379 uint cargo_index;
380 for (cargo_index = 0; cargo_index < lengthof(ind->accepts_cargo); cargo_index++) {
381 if (ind->accepts_cargo[cargo_index] != CT_INVALID) break;
382 }
383 if (cargo_index >= lengthof(ind->accepts_cargo)) return;
384
385 this->industries_near.insert(IndustryListEntry{distance, ind});
386 }
387
392 void Station::RemoveIndustryToDeliver(Industry *ind) {
393 auto pos = std::find_if(this->industries_near.begin(), this->industries_near.end(), [&](const IndustryListEntry &e) { return e.industry->index == ind->index; });
394 if (pos != this->industries_near.end()) {
395 this->industries_near.erase(pos);
396 }
397 }
398
399
403 void Station::RemoveFromAllNearbyLists()
404 {
405 for (Town *t : Town::Iterate()) { t->stations_near.erase(this); }
406 for (Industry *i : Industry::Iterate()) { i->stations_near.erase(this); }
407 }
408
416 bool Station::CatchmentCoversTown(TownID t) const
417 {
418 BitmapTileIterator it(this->catchment_tiles);
419 for (TileIndex tile = it; tile != INVALID_TILE; tile = ++it) {
420 if (IsTileType(tile, MP_HOUSE) && GetTownIndex(tile) == t) return true;
421 }
422 return false;
423 }
424
429 void Station::RecomputeCatchment()
430 {
431 this->industries_near.clear();
432 this->RemoveFromAllNearbyLists();
433
434 if (this->rect.IsEmpty()) {
435 this->catchment_tiles.Reset();
436 return;
437 }
438
439 if (!_settings_game.station.serve_neutral_industries && this->industry != nullptr) {
440 /* Station is associated with an industry, so we only need to deliver to that industry. */
441 this->catchment_tiles.Initialize(this->industry->location);
442 for (TileIndex tile : this->industry->location) {
443 if (IsTileType(tile, MP_INDUSTRY) && GetIndustryIndex(tile) == this->industry->index) {
444 this->catchment_tiles.SetTile(tile);
445 }
446 }
447 /* The industry's stations_near may have been computed before its neutral station was built so clear and re-add here. */
448 for (Station *st : this->industry->stations_near) {
449 st->RemoveIndustryToDeliver(this->industry);
450 }
451 this->industry->stations_near.clear();
452 this->industry->stations_near.insert(this);
453 this->industries_near.insert(IndustryListEntry{0, this->industry});
454 return;
455 }
456
457 this->catchment_tiles.Initialize(GetCatchmentRect());
458
459 /* Loop finding all station tiles */
460 TileArea ta(TileXY(this->rect.left, this->rect.top), TileXY(this->rect.right, this->rect.bottom));
461 for (TileIndex tile : ta) {
462 if (!IsTileType(tile, MP_STATION) || GetStationIndex(tile) != this->index) continue;
463
464 uint r = GetTileCatchmentRadius(tile, this);
465 if (r == CA_NONE) continue;
466
467 /* This tile sub-loop doesn't need to test any tiles, they are simply added to the catchment set. */
468 TileArea ta2 = TileArea(tile, 1, 1).Expand(r);
469 for (TileIndex tile2 : ta2) this->catchment_tiles.SetTile(tile2);
470 }
471
472 /* Search catchment tiles for towns and industries */
473 BitmapTileIterator it(this->catchment_tiles);
474 for (TileIndex tile = it; tile != INVALID_TILE; tile = ++it) {
475 if (IsTileType(tile, MP_HOUSE)) {
476 Town *t = Town::GetByTile(tile);
477 t->stations_near.insert(this);
478 }
479 if (IsTileType(tile, MP_INDUSTRY)) {
480 Industry *i = Industry::GetByTile(tile);
481
482 /* Ignore industry if it has a neutral station. It already can't be this station. */
483 if (!_settings_game.station.serve_neutral_industries && i->neutral_station != nullptr) continue;
484
485 i->stations_near.insert(this);
486
487 /* Add if we can deliver to this industry as well */
488 this->AddIndustryToDeliver(i, tile);
489 }
490 }
491 }
492
497 /* static */ void Station::RecomputeCatchmentForAll()
498 {
499 for (Station *st : Station::Iterate()) { st->RecomputeCatchment(); }
500 }
501
502 /************************************************************************/
503 /* StationRect implementation */
504 /************************************************************************/
505
506 StationRect::StationRect()
507 {
508 this->MakeEmpty();
509 }
510
511 void StationRect::MakeEmpty()
512 {
513 this->left = this->top = this->right = this->bottom = 0;
514 }
515
525 bool StationRect::PtInExtendedRect(int x, int y, int distance) const
526 {
527 return this->left - distance <= x && x <= this->right + distance &&
528 this->top - distance <= y && y <= this->bottom + distance;
529 }
530
531 bool StationRect::IsEmpty() const
532 {
533 return this->left == 0 || this->left > this->right || this->top > this->bottom;
534 }
535
536 CommandCost StationRect::BeforeAddTile(TileIndex tile, StationRectMode mode)
537 {
538 int x = TileX(tile);
539 int y = TileY(tile);
540 if (this->IsEmpty()) {
541 /* we are adding the first station tile */
542 if (mode != ADD_TEST) {
543 this->left = this->right = x;
544 this->top = this->bottom = y;
545 }
546 } else if (!this->PtInExtendedRect(x, y)) {
547 /* current rect is not empty and new point is outside this rect
548 * make new spread-out rectangle */
549 Rect new_rect = {std::min(x, this->left), std::min(y, this->top), std::max(x, this->right), std::max(y, this->bottom)};
550
551 /* check new rect dimensions against preset max */
552 int w = new_rect.Width();
553 int h = new_rect.Height();
554 if (mode != ADD_FORCE && (w > _settings_game.station.station_spread || h > _settings_game.station.station_spread)) {
555 assert(mode != ADD_TRY);
556 return_cmd_error(STR_ERROR_STATION_TOO_SPREAD_OUT);
557 }
558
559 /* spread-out ok, return true */
560 if (mode != ADD_TEST) {
561 /* we should update the station rect */
562 *this = new_rect;
563 }
564 } else {
565 ; // new point is inside the rect, we don't need to do anything
566 }
567 return CommandCost();
568 }
569
570 CommandCost StationRect::BeforeAddRect(TileIndex tile, int w, int h, StationRectMode mode)
571 {
572 if (mode == ADD_FORCE || (w <= _settings_game.station.station_spread && h <= _settings_game.station.station_spread)) {
573 /* Important when the old rect is completely inside the new rect, resp. the old one was empty. */
574 CommandCost ret = this->BeforeAddTile(tile, mode);
575 if (ret.Succeeded()) ret = this->BeforeAddTile(TILE_ADDXY(tile, w - 1, h - 1), mode);
576 return ret;
577 }
578 return CommandCost();
579 }
580
590 /* static */ bool StationRect::ScanForStationTiles(StationID st_id, int left_a, int top_a, int right_a, int bottom_a)
591 {
592 TileArea ta(TileXY(left_a, top_a), TileXY(right_a, bottom_a));
593 for (TileIndex tile : ta) {
594 if (IsTileType(tile, MP_STATION) && GetStationIndex(tile) == st_id) return true;
595 }
596
597 return false;
598 }
599
600 bool StationRect::AfterRemoveTile(BaseStation *st, TileIndex tile)
601 {
602 int x = TileX(tile);
603 int y = TileY(tile);
604
605 /* look if removed tile was on the bounding rect edge
606 * and try to reduce the rect by this edge
607 * do it until we have empty rect or nothing to do */
608 for (;;) {
609 /* check if removed tile is on rect edge */
610 bool left_edge = (x == this->left);
611 bool right_edge = (x == this->right);
612 bool top_edge = (y == this->top);
613 bool bottom_edge = (y == this->bottom);
614
615 /* can we reduce the rect in either direction? */
616 bool reduce_x = ((left_edge || right_edge) && !ScanForStationTiles(st->index, x, this->top, x, this->bottom));
617 bool reduce_y = ((top_edge || bottom_edge) && !ScanForStationTiles(st->index, this->left, y, this->right, y));
618 if (!(reduce_x || reduce_y)) break; // nothing to do (can't reduce)
619
620 if (reduce_x) {
621 /* reduce horizontally */
622 if (left_edge) {
623 /* move left edge right */
624 this->left = x = x + 1;
625 } else {
626 /* move right edge left */
627 this->right = x = x - 1;
628 }
629 }
630 if (reduce_y) {
631 /* reduce vertically */
632 if (top_edge) {
633 /* move top edge down */
634 this->top = y = y + 1;
635 } else {
636 /* move bottom edge up */
637 this->bottom = y = y - 1;
638 }
639 }
640
641 if (left > right || top > bottom) {
642 /* can't continue, if the remaining rectangle is empty */
643 this->MakeEmpty();
644 return true; // empty remaining rect
645 }
646 }
647 return false; // non-empty remaining rect
648 }
649
650 bool StationRect::AfterRemoveRect(BaseStation *st, TileArea ta)
651 {
652 assert(this->PtInExtendedRect(TileX(ta.tile), TileY(ta.tile)));
653 assert(this->PtInExtendedRect(TileX(ta.tile) + ta.w - 1, TileY(ta.tile) + ta.h - 1));
654
655 bool empty = this->AfterRemoveTile(st, ta.tile);
656 if (ta.w != 1 || ta.h != 1) empty = empty || this->AfterRemoveTile(st, TILE_ADDXY(ta.tile, ta.w - 1, ta.h - 1));
657 return empty;
658 }
659
660 StationRect& StationRect::operator = (const Rect &src)
661 {
662 this->left = src.left;
663 this->top = src.top;
664 this->right = src.right;
665 this->bottom = src.bottom;
666 return *this;
667 }
668
674 Money AirportMaintenanceCost(Owner owner)
675 {
676 Money total_cost = 0;
677
678 for (const Station *st : Station::Iterate()) {
679 if (st->owner == owner && (st->facilities & FACIL_AIRPORT)) {
680 total_cost += _price[PR_INFRASTRUCTURE_AIRPORT] * st->airport.GetSpec()->maintenance_cost;
681 }
682 }
683 /* 3 bits fraction for the maintenance cost factor. */
684 return total_cost >> 3;
685 }
686
687 bool StationCompare::operator() (const Station *lhs, const Station *rhs) const
688 {
689 return lhs->index < rhs->index;
690 }
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:51
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:83
WC_ROADVEH_LIST
@ WC_ROADVEH_LIST
Road vehicle list; Window numbers:
Definition: window_type.h:307
BaseStation::speclist
std::vector< StationSpecList > speclist
List of rail station specs of this station.
Definition: base_station_base.h:65
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:3252
Station::goods
GoodsEntry goods[NUM_CARGO]
Goods at this station.
Definition: station_base.h:483
HasTileAnyRoadType
static bool HasTileAnyRoadType(TileIndex t, RoadTypes rts)
Check if a tile has one of the specified road types.
Definition: road_map.h:222
StationRect
StationRect - used to track station spread out rectangle - cheaper than scanning whole map.
Definition: base_station_base.h:29
Rect::Height
int Height() const
Get height of Rect.
Definition: geometry_type.hpp:85
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:598
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:264
ROADSTOP_TRUCK
@ ROADSTOP_TRUCK
A standard stop for trucks.
Definition: station_type.h:46
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:3586
Pool::PoolItem<&_link_graph_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:348
CA_NONE
@ CA_NONE
Catchment when the station has no facilities.
Definition: station_type.h:77
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:454
Station::RecomputeCatchment
void RecomputeCatchment()
Recompute tiles covered in our catchment area.
Definition: station.cpp:429
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:181
_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:938
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:235
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:525
INVALID_TILE
static constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:108
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
TileIndex
The index/ID of a Tile.
Definition: tile_type.h:85
Station::MoveSign
void MoveSign(TileIndex new_xy) override
Move the station main coordinate somewhere else.
Definition: station_cmd.cpp:438
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:52
SpecializedStation< Station, false >::Get
static Station * Get(size_t index)
Gets station with given index.
Definition: base_station_base.h:218
MP_INDUSTRY
@ MP_INDUSTRY
Part of an industry.
Definition: tile_type.h:56
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:286
LinkGraph::Size
NodeID Size() const
Get the current size of the component.
Definition: linkgraph.h:508
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:224
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:416
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:128
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:151
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:269
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:252
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:4625
StationSettings::serve_neutral_industries
bool serve_neutral_industries
company stations can serve industries with attached neutral stations
Definition: settings_type.h:559
return_cmd_error
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
Definition: command_func.h:38
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:24
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
BaseStation::train_station
TileArea train_station
Tile area the train 'station' part covers.
Definition: base_station_base.h:74
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:497
BaseStation::random_bits
uint16 random_bits
Random bits assigned to this station.
Definition: base_station_base.h:69
roadstop_base.h
BaseStation::rect
StationRect rect
NOSAVE: Station spread out rectangle maintained by StationRect::xxx() functions.
Definition: base_station_base.h:75
TileIndexDiff
int32 TileIndexDiff
An offset value between two 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:215
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:20
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:468
OrthogonalTileArea
Represents the covered area of e.g.
Definition: tilearea_type.h:18
Station::AddFacility
void AddFacility(StationFacility new_facility_bit, TileIndex facil_xy)
Called when new facility is built on the station.
Definition: station.cpp:199
Station::TileBelongsToRailStation
bool TileBelongsToRailStation(TileIndex tile) const override
Check whether a specific tile belongs to this station.
Definition: station_base.h:519
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:54
ViewportSign::MarkDirty
void MarkDirty(ZoomLevel maxzoom=ZOOM_LVL_MAX) const
Mark the sign dirty in all viewports.
Definition: viewport.cpp:1478
Station::~Station
~Station()
Clean up a station by clearing vehicle orders, invalidating windows and removing link stats.
Definition: station.cpp:84
industry.h
safeguards.h
CA_BUS
@ CA_BUS
Catchment for bus stops with "modified catchment" enabled.
Definition: station_type.h:78
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
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:674
CA_TRUCK
@ CA_TRUCK
Catchment for truck stops with "modified catchment" enabled.
Definition: station_type.h:79
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:563
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:465
Station::industry
Industry * industry
NOSAVE: Associated industry for neutral stations. (Rebuilt on load from Industry->st)
Definition: station_base.h:487
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:590
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:51
OrthogonalTileArea::h
uint16 h
The height of the area.
Definition: tilearea_type.h:21
DistanceMax
uint DistanceMax(TileIndex t0, TileIndex t1)
Gets the biggest distance component (x or y) between the two given tiles.
Definition: map.cpp:189
CA_DOCK
@ CA_DOCK
Catchment for docks with "modified catchment" enabled.
Definition: station_type.h:81
ROADSTOP_BUS
@ ROADSTOP_BUS
A standard stop for buses.
Definition: station_type.h:45
Station::industries_near
IndustryList industries_near
Cached list of industries near the station that can accept cargo,.
Definition: station_base.h:486
_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:386
Pool
Base class for all pools.
Definition: pool_type.hpp:81
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:111
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:256
Station::GetCatchmentRadius
uint GetCatchmentRadius() const
Determines the catchment radius of the station.
Definition: station.cpp:316
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition: tilearea_type.h:19
RemoveOrderFromAllVehicles
void RemoveOrderFromAllVehicles(OrderType type, DestinationID destination, bool hangar)
Removes an order from all vehicles.
Definition: order_cmd.cpp:1765
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:3269
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:316
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:1998
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:53
NUM_CARGO
@ NUM_CARGO
Maximal number of cargo types in a game.
Definition: cargo_type.h:65
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:931
TrackedViewportSign::kdtree_valid
bool kdtree_valid
Are the sign data valid for use with the _viewport_sign_kdtree?
Definition: viewport_type.h:50
Station::GetCatchmentRect
Rect GetCatchmentRect() const
Determines catchment rectangle of this station.
Definition: station.cpp:339
Station::RemoveIndustryToDeliver
void RemoveIndustryToDeliver(Industry *ind)
Remove nearby industry from station's industries_near list.
Definition: station.cpp:392
linkgraph.h
Station::catchment_tiles
BitmapTileArea catchment_tiles
NOSAVE: Set of individual tiles covered by catchment area.
Definition: station_base.h:474
BaseStation::xy
TileIndex xy
Base tile of the station.
Definition: base_station_base.h:53
BaseStation
Base class for all station-ish types.
Definition: base_station_base.h:52
IndustryListEntry
Definition: station_base.h:440
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:1252
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
AXIS_X
@ AXIS_X
The X axis.
Definition: direction_type.h:126
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:102
Town
Town data structure.
Definition: town.h:50
lengthof
#define lengthof(x)
Return the length of an fixed size array.
Definition: stdafx.h:386
Station::RemoveFromAllNearbyLists
void RemoveFromAllNearbyLists()
Remove this station from the nearby stations lists of all towns and industries.
Definition: station.cpp:403
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:168
CA_TRAIN
@ CA_TRAIN
Catchment for train stations with "modified catchment" enabled.
Definition: station_type.h:80
random_func.hpp
OverflowSafeInt< int64 >
CargoID
byte CargoID
Cargo slots to indicate a cargo type within a game.
Definition: cargo_type.h:20
CloseWindowById
void CloseWindowById(WindowClass cls, WindowNumber number, bool force)
Close a window by its class and window number (if it is open).
Definition: window.cpp:1187
RoadVehicle::IsBus
bool IsBus() const
Check whether a roadvehicle is a bus.
Definition: roadveh_cmd.cpp:81
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:463
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:56
Airport::psa
PersistentStorage * psa
Persistent storage for NewGRF airports.
Definition: station_base.h:310
Rect::Width
int Width() const
Get width of Rect.
Definition: geometry_type.hpp:79
Airport::GetSpec
const AirportSpec * GetSpec() const
Get the AirportSpec that from the airport type of this airport.
Definition: station_base.h:317
pool_func.hpp
CT_INVALID
@ CT_INVALID
Invalid cargo type.
Definition: cargo_type.h:69
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:69
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:67
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:469
Station::AddIndustryToDeliver
void AddIndustryToDeliver(Industry *ind, TileIndex tile)
Add nearby industry to station's industries_near list if it accepts cargo.
Definition: station.cpp:362
StationSettings::modified_catchment
bool modified_catchment
different-size catchment areas
Definition: settings_type.h:558
news_func.h
roadveh.h