OpenTTD Source: src/waypoint_cmd.cpp Source File

OpenTTD Source 15.0-beta1

waypoint_cmd.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
12#include "command_func.h"
13#include "landscape.h"
14#include "bridge_map.h"
15#include "town.h"
16#include "waypoint_base.h"
17#include "pathfinder/yapf/yapf_cache.h"
18#include "pathfinder/water_regions.h"
19#include "strings_func.h"
20#include "viewport_func.h"
21#include "viewport_kdtree.h"
22#include "window_func.h"
23#include "timer/timer_game_calendar.h"
24#include "vehicle_func.h"
25#include "string_func.h"
26#include "company_func.h"
27#include "newgrf_station.h"
28#include "newgrf_roadstop.h"
29#include "company_base.h"
30#include "water.h"
31#include "company_gui.h"
32#include "waypoint_cmd.h"
33#include "landscape_cmd.h"
34
35#include "table/strings.h"
36
37#include "safeguards.h"
38
42 void Waypoint::UpdateVirtCoord()
43{
44 Point pt = RemapCoords2(TileX(this->xy) * TILE_SIZE, TileY(this->xy) * TILE_SIZE);
45 if (this->sign.kdtree_valid) _viewport_sign_kdtree.Remove(ViewportSignKdtreeItem::MakeWaypoint(this->index));
46
47 SetDParam(0, this->index);
48 this->sign.UpdatePosition(pt.x, pt.y - 32 * ZOOM_BASE, STR_VIEWPORT_WAYPOINT);
49
50 _viewport_sign_kdtree.Insert(ViewportSignKdtreeItem::MakeWaypoint(this->index));
51
52 /* Recenter viewport */
53 InvalidateWindowData(WC_WAYPOINT_VIEW, this->index);
54}
55
60 void Waypoint::MoveSign(TileIndex new_xy)
61{
62 if (this->xy == new_xy) return;
63
64 this->BaseStation::MoveSign(new_xy);
65}
66
75 static Waypoint *FindDeletedWaypointCloseTo(TileIndex tile, StringID str, CompanyID cid, bool is_road)
76{
77 Waypoint *best = nullptr;
78 uint thres = 8;
79
80 for (Waypoint *wp : Waypoint::Iterate()) {
81 if (!wp->IsInUse() && wp->string_id == str && wp->owner == cid && HasBit(wp->waypoint_flags, WPF_ROAD) == is_road) {
82 uint cur_dist = DistanceManhattan(tile, wp->xy);
83
84 if (cur_dist < thres) {
85 thres = cur_dist;
86 best = wp;
87 }
88 }
89 }
90
91 return best;
92}
93
101 Axis GetAxisForNewRailWaypoint(TileIndex tile)
102{
103 /* The axis for rail waypoints is easy. */
104 if (IsRailWaypointTile(tile)) return GetRailStationAxis(tile);
105
106 /* Non-plain rail type, no valid axis for waypoints. */
107 if (!IsTileType(tile, MP_RAILWAY) || GetRailTileType(tile) != RAIL_TILE_NORMAL) return INVALID_AXIS;
108
109 switch (GetTrackBits(tile)) {
110 case TRACK_BIT_X: return AXIS_X;
111 case TRACK_BIT_Y: return AXIS_Y;
112 default: return INVALID_AXIS;
113 }
114}
115
123 Axis GetAxisForNewRoadWaypoint(TileIndex tile)
124{
125 /* The axis for existing road waypoints is easy. */
126 if (IsRoadWaypointTile(tile)) return GetDriveThroughStopAxis(tile);
127
128 /* Non-plain road type, no valid axis for waypoints. */
129 if (!IsNormalRoadTile(tile)) return INVALID_AXIS;
130
131 RoadBits bits = GetAllRoadBits(tile);
132
133 if ((bits & ROAD_Y) == 0) return AXIS_X;
134 if ((bits & ROAD_X) == 0) return AXIS_Y;
135
136 return INVALID_AXIS;
137}
138
139extern CommandCost ClearTile_Station(TileIndex tile, DoCommandFlag flags);
140
147 static CommandCost IsValidTileForWaypoint(TileIndex tile, Axis axis, StationID *waypoint)
148{
149 /* if waypoint is set, then we have special handling to allow building on top of already existing waypoints.
150 * so waypoint points to INVALID_STATION if we can build on any waypoint.
151 * Or it points to a waypoint if we're only allowed to build on exactly that waypoint. */
152 if (waypoint != nullptr && IsTileType(tile, MP_STATION)) {
153 if (!IsRailWaypoint(tile)) {
154 return ClearTile_Station(tile, DC_AUTO); // get error message
155 } else {
156 StationID wp = GetStationIndex(tile);
157 if (*waypoint == INVALID_STATION) {
158 *waypoint = wp;
159 } else if (*waypoint != wp) {
160 return CommandCost(STR_ERROR_WAYPOINT_ADJOINS_MORE_THAN_ONE_EXISTING);
161 }
162 }
163 }
164
165 if (GetAxisForNewRailWaypoint(tile) != axis) return CommandCost(STR_ERROR_NO_SUITABLE_RAILROAD_TRACK);
166
167 Owner owner = GetTileOwner(tile);
168 CommandCost ret = CheckOwnership(owner);
169 if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile);
170 if (ret.Failed()) return ret;
171
172 Slope tileh = GetTileSlope(tile);
173 if (tileh != SLOPE_FLAT &&
174 (!_settings_game.construction.build_on_slopes || IsSteepSlope(tileh) || !(tileh & (0x3 << axis)) || !(tileh & ~(0x3 << axis)))) {
175 return CommandCost(STR_ERROR_FLAT_LAND_REQUIRED);
176 }
177
178 if (IsBridgeAbove(tile)) return CommandCost(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
179
180 return CommandCost();
181}
182
183extern void GetStationLayout(uint8_t *layout, uint numtracks, uint plat_len, const StationSpec *statspec);
184extern CommandCost FindJoiningWaypoint(StationID existing_station, StationID station_to_join, bool adjacent, TileArea ta, Waypoint **wp, bool is_road);
185extern CommandCost CanExpandRailStation(const BaseStation *st, TileArea &new_ta);
186extern CommandCost CalculateRoadStopCost(TileArea tile_area, DoCommandFlag flags, bool is_drive_through, StationType station_type, Axis axis, DiagDirection ddir, StationID *est, RoadType rt, Money unit_cost);
187extern CommandCost RemoveRoadWaypointStop(TileIndex tile, DoCommandFlag flags, int replacement_spec_index);
188
203 CommandCost CmdBuildRailWaypoint(DoCommandFlag flags, TileIndex start_tile, Axis axis, uint8_t width, uint8_t height, StationClassID spec_class, uint16_t spec_index, StationID station_to_join, bool adjacent)
204{
205 if (!IsValidAxis(axis)) return CMD_ERROR;
206 /* Check if the given station class is valid */
207 if (static_cast<uint>(spec_class) >= StationClass::GetClassCount()) return CMD_ERROR;
208 const StationClass *cls = StationClass::Get(spec_class);
209 if (!IsWaypointClass(*cls)) return CMD_ERROR;
210 if (spec_index >= cls->GetSpecCount()) return CMD_ERROR;
211
212 /* The number of parts to build */
213 uint8_t count = axis == AXIS_X ? height : width;
214
215 if ((axis == AXIS_X ? width : height) != 1) return CMD_ERROR;
216 if (count == 0 || count > _settings_game.station.station_spread) return CMD_ERROR;
217
218 bool reuse = (station_to_join != NEW_STATION);
219 if (!reuse) station_to_join = INVALID_STATION;
220 bool distant_join = (station_to_join != INVALID_STATION);
221
222 if (distant_join && (!_settings_game.station.distant_join_stations || !Waypoint::IsValidID(station_to_join))) return CMD_ERROR;
223
224 TileArea new_location(start_tile, width, height);
225
226 /* only AddCost for non-existing waypoints */
227 CommandCost cost(EXPENSES_CONSTRUCTION);
228 for (TileIndex cur_tile : new_location) {
229 if (!IsRailWaypointTile(cur_tile)) cost.AddCost(_price[PR_BUILD_WAYPOINT_RAIL]);
230 }
231
232 /* Make sure the area below consists of clear tiles. (OR tiles belonging to a certain rail station) */
233 StationID est = INVALID_STATION;
234
235 /* Check whether the tiles we're building on are valid rail or not. */
236 TileIndexDiff offset = TileOffsByAxis(OtherAxis(axis));
237 for (int i = 0; i < count; i++) {
238 TileIndex tile = start_tile + i * offset;
239 CommandCost ret = IsValidTileForWaypoint(tile, axis, &est);
240 if (ret.Failed()) return ret;
241 }
242
243 Waypoint *wp = nullptr;
244 CommandCost ret = FindJoiningWaypoint(est, station_to_join, adjacent, new_location, &wp, false);
245 if (ret.Failed()) return ret;
246
247 /* Check if there is an already existing, deleted, waypoint close to us that we can reuse. */
248 TileIndex center_tile = start_tile + (count / 2) * offset;
249 if (wp == nullptr && reuse) wp = FindDeletedWaypointCloseTo(center_tile, STR_SV_STNAME_WAYPOINT, _current_company, false);
250
251 if (wp != nullptr) {
252 /* Reuse an existing waypoint. */
253 if (wp->owner != _current_company) return CommandCost(STR_ERROR_TOO_CLOSE_TO_ANOTHER_WAYPOINT);
254
255 /* Check if we want to expand an already existing waypoint. */
256 if (wp->train_station.tile != INVALID_TILE) {
257 ret = CanExpandRailStation(wp, new_location);
258 if (ret.Failed()) return ret;
259 }
260
261 ret = wp->rect.BeforeAddRect(start_tile, width, height, StationRect::ADD_TEST);
262 if (ret.Failed()) return ret;
263 } else {
264 /* Check if we can create a new waypoint. */
265 if (!Waypoint::CanAllocateItem()) return CommandCost(STR_ERROR_TOO_MANY_STATIONS_LOADING);
266 }
267
268 if (flags & DC_EXEC) {
269 if (wp == nullptr) {
270 wp = new Waypoint(start_tile);
271 } else if (!wp->IsInUse()) {
272 /* Move existing (recently deleted) waypoint to the new location */
273 wp->xy = start_tile;
274 }
275 wp->owner = GetTileOwner(start_tile);
276
277 wp->rect.BeforeAddRect(start_tile, width, height, StationRect::ADD_TRY);
278
279 wp->delete_ctr = 0;
280 wp->facilities |= FACIL_TRAIN;
281 wp->build_date = TimerGameCalendar::date;
282 wp->string_id = STR_SV_STNAME_WAYPOINT;
283 wp->train_station = new_location;
284
285 if (wp->town == nullptr) MakeDefaultName(wp);
286
287 wp->UpdateVirtCoord();
288
289 const StationSpec *spec = StationClass::Get(spec_class)->GetSpec(spec_index);
290 std::vector<uint8_t> layout(count);
291 if (spec != nullptr) {
292 /* For NewGRF waypoints we like to have their style. */
293 GetStationLayout(layout.data(), count, 1, spec);
294 }
295 uint8_t map_spec_index = AllocateSpecToStation(spec, wp, true);
296
297 Company *c = Company::Get(wp->owner);
298 for (int i = 0; i < count; i++) {
299 TileIndex tile = start_tile + i * offset;
300 uint8_t old_specindex = HasStationTileRail(tile) ? GetCustomStationSpecIndex(tile) : 0;
301 if (!HasStationTileRail(tile)) c->infrastructure.station++;
302 bool reserved = IsTileType(tile, MP_RAILWAY) ?
303 HasBit(GetRailReservationTrackBits(tile), AxisToTrack(axis)) :
304 HasStationReservation(tile);
305 MakeRailWaypoint(tile, wp->owner, wp->index, axis, layout[i], GetRailType(tile));
306 SetCustomStationSpecIndex(tile, map_spec_index);
307
308 SetRailStationTileFlags(tile, spec);
309
310 SetRailStationReservation(tile, reserved);
311 MarkTileDirtyByTile(tile);
312
313 DeallocateSpecFromStation(wp, old_specindex);
314 YapfNotifyTrackLayoutChange(tile, AxisToTrack(axis));
315 }
316 DirtyCompanyInfrastructureWindows(wp->owner);
317 }
318
319 return cost;
320}
321
335 CommandCost CmdBuildRoadWaypoint(DoCommandFlag flags, TileIndex start_tile, Axis axis, uint8_t width, uint8_t height, RoadStopClassID spec_class, uint16_t spec_index, StationID station_to_join, bool adjacent)
336{
337 if (!IsValidAxis(axis)) return CMD_ERROR;
338 /* Check if the given station class is valid */
339 if (static_cast<uint>(spec_class) >= RoadStopClass::GetClassCount()) return CMD_ERROR;
340 const RoadStopClass *cls = RoadStopClass::Get(spec_class);
341 if (!IsWaypointClass(*cls)) return CMD_ERROR;
342 if (spec_index >= cls->GetSpecCount()) return CMD_ERROR;
343
344 const RoadStopSpec *roadstopspec = RoadStopClass::Get(spec_class)->GetSpec(spec_index);
345
346 /* The number of parts to build */
347 uint8_t count = axis == AXIS_X ? height : width;
348
349 if ((axis == AXIS_X ? width : height) != 1) return CMD_ERROR;
350 if (count == 0 || count > _settings_game.station.station_spread) return CMD_ERROR;
351
352 bool reuse = (station_to_join != NEW_STATION);
353 if (!reuse) station_to_join = INVALID_STATION;
354 bool distant_join = (station_to_join != INVALID_STATION);
355
356 if (distant_join && (!_settings_game.station.distant_join_stations || !Waypoint::IsValidID(station_to_join))) return CMD_ERROR;
357
358 TileArea roadstop_area(start_tile, width, height);
359
360 /* Total road stop cost. */
361 Money unit_cost;
362 if (roadstopspec != nullptr) {
363 unit_cost = roadstopspec->GetBuildCost(PR_BUILD_STATION_TRUCK);
364 } else {
365 unit_cost = _price[PR_BUILD_STATION_TRUCK];
366 }
367 StationID est = INVALID_STATION;
368 CommandCost cost = CalculateRoadStopCost(roadstop_area, flags, true, STATION_ROADWAYPOINT, axis, AxisToDiagDir(axis), &est, INVALID_ROADTYPE, unit_cost);
369 if (cost.Failed()) return cost;
370
371 Waypoint *wp = nullptr;
372 CommandCost ret = FindJoiningWaypoint(est, station_to_join, adjacent, roadstop_area, &wp, true);
373 if (ret.Failed()) return ret;
374
375 /* Check if there is an already existing, deleted, waypoint close to us that we can reuse. */
376 TileIndex center_tile = start_tile + (count / 2) * TileOffsByAxis(OtherAxis(axis));
377 if (wp == nullptr && reuse) wp = FindDeletedWaypointCloseTo(center_tile, STR_SV_STNAME_WAYPOINT, _current_company, true);
378
379 if (wp != nullptr) {
380 /* Reuse an existing waypoint. */
381 if (!HasBit(wp->waypoint_flags, WPF_ROAD)) return CMD_ERROR;
382 if (wp->owner != _current_company) return CommandCost(STR_ERROR_TOO_CLOSE_TO_ANOTHER_WAYPOINT);
383
384 ret = wp->rect.BeforeAddRect(start_tile, width, height, StationRect::ADD_TEST);
385 if (ret.Failed()) return ret;
386 } else {
387 /* Check if we can create a new waypoint. */
388 if (!Waypoint::CanAllocateItem()) return CommandCost(STR_ERROR_TOO_MANY_STATIONS_LOADING);
389 }
390
391 /* Check if we can allocate a custom stationspec to this station */
392 if (AllocateSpecToRoadStop(roadstopspec, wp, false) == -1) return CommandCost(STR_ERROR_TOO_MANY_STATION_SPECS);
393
394 if (flags & DC_EXEC) {
395 if (wp == nullptr) {
396 wp = new Waypoint(start_tile);
397 SetBit(wp->waypoint_flags, WPF_ROAD);
398 } else if (!wp->IsInUse()) {
399 /* Move existing (recently deleted) waypoint to the new location */
400 wp->xy = start_tile;
401 }
402 wp->owner = _current_company;
403
404 wp->rect.BeforeAddRect(start_tile, width, height, StationRect::ADD_TRY);
405
406 if (roadstopspec != nullptr) {
407 /* Include this road stop spec's animation trigger bitmask
408 * in the station's cached copy. */
409 wp->cached_roadstop_anim_triggers |= roadstopspec->animation.triggers;
410 }
411
412 wp->delete_ctr = 0;
413 wp->facilities |= FACIL_BUS_STOP | FACIL_TRUCK_STOP;
414 wp->build_date = TimerGameCalendar::date;
415 wp->string_id = STR_SV_STNAME_WAYPOINT;
416
417 if (wp->town == nullptr) MakeDefaultName(wp);
418
419 wp->UpdateVirtCoord();
420
421 uint8_t map_spec_index = AllocateSpecToRoadStop(roadstopspec, wp, true);
422
423 /* Check every tile in the area. */
424 for (TileIndex cur_tile : roadstop_area) {
425 /* Get existing road types and owners before any tile clearing */
426 RoadType road_rt = MayHaveRoad(cur_tile) ? GetRoadType(cur_tile, RTT_ROAD) : INVALID_ROADTYPE;
427 RoadType tram_rt = MayHaveRoad(cur_tile) ? GetRoadType(cur_tile, RTT_TRAM) : INVALID_ROADTYPE;
428 Owner road_owner = road_rt != INVALID_ROADTYPE ? GetRoadOwner(cur_tile, RTT_ROAD) : _current_company;
429 Owner tram_owner = tram_rt != INVALID_ROADTYPE ? GetRoadOwner(cur_tile, RTT_TRAM) : _current_company;
430
431 if (IsRoadWaypointTile(cur_tile)) {
432 RemoveRoadWaypointStop(cur_tile, flags, map_spec_index);
433 }
434
435 wp->road_waypoint_area.Add(cur_tile);
436
437 wp->rect.BeforeAddTile(cur_tile, StationRect::ADD_TRY);
438
439 /* Update company infrastructure counts. If the current tile is a normal road tile, remove the old
440 * bits first. */
441 if (IsNormalRoadTile(cur_tile)) {
442 UpdateCompanyRoadInfrastructure(road_rt, road_owner, -(int)CountBits(GetRoadBits(cur_tile, RTT_ROAD)));
443 UpdateCompanyRoadInfrastructure(tram_rt, tram_owner, -(int)CountBits(GetRoadBits(cur_tile, RTT_TRAM)));
444 }
445
446 UpdateCompanyRoadInfrastructure(road_rt, road_owner, ROAD_STOP_TRACKBIT_FACTOR);
447 UpdateCompanyRoadInfrastructure(tram_rt, tram_owner, ROAD_STOP_TRACKBIT_FACTOR);
448
449 MakeDriveThroughRoadStop(cur_tile, wp->owner, road_owner, tram_owner, wp->index, STATION_ROADWAYPOINT, road_rt, tram_rt, axis);
450 SetCustomRoadStopSpecIndex(cur_tile, map_spec_index);
451 if (roadstopspec != nullptr) wp->SetRoadStopRandomBits(cur_tile, 0);
452
453 Company::Get(wp->owner)->infrastructure.station++;
454
455 MarkTileDirtyByTile(cur_tile);
456 }
457 DirtyCompanyInfrastructureWindows(wp->owner);
458 }
459 return cost;
460}
461
468 CommandCost CmdBuildBuoy(DoCommandFlag flags, TileIndex tile)
469{
470 if (tile == 0 || !HasTileWaterGround(tile)) return CommandCost(STR_ERROR_SITE_UNSUITABLE);
471 if (IsBridgeAbove(tile)) return CommandCost(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
472
473 if (!IsTileFlat(tile)) return CommandCost(STR_ERROR_SITE_UNSUITABLE);
474
475 /* Check if there is an already existing, deleted, waypoint close to us that we can reuse. */
476 Waypoint *wp = FindDeletedWaypointCloseTo(tile, STR_SV_STNAME_BUOY, OWNER_NONE, false);
477 if (wp == nullptr && !Waypoint::CanAllocateItem()) return CommandCost(STR_ERROR_TOO_MANY_STATIONS_LOADING);
478
479 CommandCost cost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_WAYPOINT_BUOY]);
480 if (!IsWaterTile(tile)) {
481 CommandCost ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags | DC_AUTO, tile);
482 if (ret.Failed()) return ret;
483 cost.AddCost(ret);
484 }
485
486 if (flags & DC_EXEC) {
487 if (wp == nullptr) {
488 wp = new Waypoint(tile);
489 } else {
490 /* Move existing (recently deleted) buoy to the new location */
491 wp->xy = tile;
492 InvalidateWindowData(WC_WAYPOINT_VIEW, wp->index);
493 }
494 wp->rect.BeforeAddTile(tile, StationRect::ADD_TRY);
495
496 wp->string_id = STR_SV_STNAME_BUOY;
497
498 wp->facilities |= FACIL_DOCK;
499 wp->owner = OWNER_NONE;
500
501 wp->build_date = TimerGameCalendar::date;
502
503 if (wp->town == nullptr) MakeDefaultName(wp);
504
505 MakeBuoy(tile, wp->index, GetWaterClass(tile));
506 CheckForDockingTile(tile);
507 MarkTileDirtyByTile(tile);
508 ClearNeighbourNonFloodingStates(tile);
509
510 wp->UpdateVirtCoord();
511 InvalidateWindowData(WC_WAYPOINT_VIEW, wp->index);
512 }
513
514 return cost;
515}
516
524 CommandCost RemoveBuoy(TileIndex tile, DoCommandFlag flags)
525{
526 /* XXX: strange stuff, allow clearing as invalid company when clearing landscape */
527 if (!Company::IsValidID(_current_company) && !(flags & DC_BANKRUPT)) return CommandCost(INVALID_STRING_ID);
528
529 Waypoint *wp = Waypoint::GetByTile(tile);
530
531 if (HasStationInUse(wp->index, false, _current_company)) return CommandCost(STR_ERROR_BUOY_IS_IN_USE);
532 /* remove the buoy if there is a ship on tile when company goes bankrupt... */
533 if (!(flags & DC_BANKRUPT)) {
534 CommandCost ret = EnsureNoVehicleOnGround(tile);
535 if (ret.Failed()) return ret;
536 }
537
538 if (flags & DC_EXEC) {
539 wp->facilities &= ~FACIL_DOCK;
540
541 InvalidateWindowData(WC_WAYPOINT_VIEW, wp->index);
542
543 /* We have to set the water tile's state to the same state as before the
544 * buoy was placed. Otherwise one could plant a buoy on a canal edge,
545 * remove it and flood the land (if the canal edge is at level 0) */
546 MakeWaterKeepingClass(tile, GetTileOwner(tile));
547
548 wp->rect.AfterRemoveTile(wp, tile);
549
550 wp->UpdateVirtCoord();
551 wp->delete_ctr = 0;
552 }
553
554 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_WAYPOINT_BUOY]);
555}
556
562 static bool IsUniqueWaypointName(const std::string &name)
563{
564 for (const Waypoint *wp : Waypoint::Iterate()) {
565 if (!wp->name.empty() && wp->name == name) return false;
566 }
567
568 return true;
569}
570
578 CommandCost CmdRenameWaypoint(DoCommandFlag flags, StationID waypoint_id, const std::string &text)
579{
580 Waypoint *wp = Waypoint::GetIfValid(waypoint_id);
581 if (wp == nullptr) return CMD_ERROR;
582
583 if (wp->owner != OWNER_NONE) {
584 CommandCost ret = CheckOwnership(wp->owner);
585 if (ret.Failed()) return ret;
586 }
587
588 bool reset = text.empty();
589
590 if (!reset) {
591 if (Utf8StringLength(text) >= MAX_LENGTH_STATION_NAME_CHARS) return CMD_ERROR;
592 if (!IsUniqueWaypointName(text)) return CommandCost(STR_ERROR_NAME_MUST_BE_UNIQUE);
593 }
594
595 if (flags & DC_EXEC) {
596 if (reset) {
597 wp->name.clear();
598 } else {
599 wp->name = text;
600 }
601
602 wp->UpdateVirtCoord();
603 }
604 return CommandCost();
605}
HasBit
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition bitmath_func.hpp:103
SetBit
constexpr T SetBit(T &x, const uint8_t y)
Set a bit in a variable.
Definition bitmath_func.hpp:121
CountBits
constexpr uint CountBits(T value)
Counts the number of set bits in a variable.
Definition bitmath_func.hpp:262
bridge_map.h
Map accessor functions for bridges.
IsBridgeAbove
bool IsBridgeAbove(Tile t)
checks if a bridge is set above the ground of this tile
Definition bridge_map.h:45
CommandCost
Common return value for all commands.
Definition command_type.h:23
CommandCost::Succeeded
bool Succeeded() const
Did this command succeed?
Definition command_type.h:162
CommandCost::AddCost
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
Definition command_type.h:63
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition command_type.h:171
Kdtree::Insert
void Insert(const T &element)
Insert a single element in the tree.
Definition kdtree.hpp:398
Kdtree::Remove
void Remove(const T &element)
Remove a single element from the tree, if it exists.
Definition kdtree.hpp:417
NewGRFClass
Struct containing information relating to NewGRF classes for stations and airports.
Definition newgrf_class.h:26
NewGRFClass::Get
static NewGRFClass * Get(Tindex class_index)
Get a particular class.
Definition newgrf_class_func.h:82
NewGRFClass::GetSpecCount
uint GetSpecCount() const
Get the number of allocated specs within the class.
Definition newgrf_class.h:70
NewGRFClass::GetClassCount
static uint GetClassCount()
Get the number of allocated classes.
Definition newgrf_class_func.h:93
NewGRFClass::GetSpec
const Tspec * GetSpec(uint index) const
Get a spec from the class at a given index.
Definition newgrf_class_func.h:114
OverflowSafeInt< int64_t >
TimerGameCalendar::date
static Date date
Current date in days (day counter).
Definition timer_game_calendar.h:33
command_func.h
Functions related to commands.
CMD_ERROR
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition command_func.h:28
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition command_type.h:374
DC_AUTO
@ DC_AUTO
don't allow building on structures
Definition command_type.h:377
DC_BANKRUPT
@ DC_BANKRUPT
company bankrupts, skip money check, skip vehicle on tile check in some cases
Definition command_type.h:382
DC_EXEC
@ DC_EXEC
execute the given command
Definition command_type.h:376
company_base.h
Definition of stuff that is very close to a company, like the company struct itself.
CheckOwnership
CommandCost CheckOwnership(Owner owner, TileIndex tile)
Check whether the current owner owns something.
Definition company_cmd.cpp:363
_current_company
CompanyID _current_company
Company currently doing an action.
Definition company_cmd.cpp:53
company_func.h
Functions related to companies.
DirtyCompanyInfrastructureWindows
void DirtyCompanyInfrastructureWindows(CompanyID company)
Redraw all windows with company infrastructure counts.
Definition company_gui.cpp:2606
company_gui.h
GUI Functions related to companies.
Owner
Owner
Enum for all companies/owners.
Definition company_type.h:18
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition company_type.h:25
IsValidAxis
bool IsValidAxis(Axis d)
Checks if an integer value is a valid Axis.
Definition direction_func.h:43
AxisToDiagDir
DiagDirection AxisToDiagDir(Axis a)
Converts an Axis to a DiagDirection.
Definition direction_func.h:232
OtherAxis
Axis OtherAxis(Axis a)
Select the other axis as provided.
Definition direction_func.h:197
Axis
Axis
Allow incrementing of DiagDirDiff variables.
Definition direction_type.h:116
INVALID_AXIS
@ INVALID_AXIS
Flag for an invalid Axis.
Definition direction_type.h:120
AXIS_X
@ AXIS_X
The X axis.
Definition direction_type.h:117
AXIS_Y
@ AXIS_Y
The y axis.
Definition direction_type.h:118
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition direction_type.h:73
ROAD_STOP_TRACKBIT_FACTOR
static const uint ROAD_STOP_TRACKBIT_FACTOR
Multiplier for how many regular track bits a bay stop counts.
Definition economy_type.h:247
EXPENSES_CONSTRUCTION
@ EXPENSES_CONSTRUCTION
Construction costs.
Definition economy_type.h:173
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:2057
landscape.h
Functions related to OTTD's landscape.
RemapCoords2
Point RemapCoords2(int x, int y)
Map 3D world or tile coordinate to equivalent 2D coordinate as used in the viewports and smallmap.
Definition landscape.h:95
landscape_cmd.h
Command definitions related to landscape (slopes etc.).
DistanceManhattan
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition map.cpp:146
TileOffsByAxis
TileIndexDiff TileOffsByAxis(Axis axis)
Convert an Axis to a TileIndexDiff.
Definition map_func.h:552
TileY
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:425
TileX
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:415
TileIndexDiff
int32_t TileIndexDiff
An offset value between two tiles.
Definition map_type.h:23
newgrf_roadstop.h
NewGRF definitions and structures for road stops.
IsWaypointClass
bool IsWaypointClass(const RoadStopClass &cls)
Test if a RoadStopClass is the waypoint class.
Definition newgrf_roadstop.h:200
RoadStopClassID
RoadStopClassID
Definition newgrf_roadstop.h:28
AllocateSpecToStation
int AllocateSpecToStation(const StationSpec *statspec, BaseStation *st, bool exec)
Allocate a StationSpec to a Station.
Definition newgrf_station.cpp:685
DeallocateSpecFromStation
void DeallocateSpecFromStation(BaseStation *st, uint8_t specindex)
Deallocate a StationSpec from a Station.
Definition newgrf_station.cpp:727
newgrf_station.h
Header file for NewGRF stations.
StationClassID
StationClassID
Definition newgrf_station.h:86
GetRailType
RailType GetRailType(Tile t)
Gets the rail type of the given tile.
Definition rail_map.h:115
GetRailTileType
static debug_inline RailTileType GetRailTileType(Tile t)
Returns the RailTileType (normal with or without signals, waypoint or depot).
Definition rail_map.h:36
GetTrackBits
TrackBits GetTrackBits(Tile tile)
Gets the track bits of the given tile.
Definition rail_map.h:136
GetRailReservationTrackBits
TrackBits GetRailReservationTrackBits(Tile t)
Returns the reserved track bits of the tile.
Definition rail_map.h:194
RAIL_TILE_NORMAL
@ RAIL_TILE_NORMAL
Normal rail tile without signals.
Definition rail_map.h:24
UpdateCompanyRoadInfrastructure
void UpdateCompanyRoadInfrastructure(RoadType rt, Owner o, int count)
Update road infrastructure counts for a company.
Definition road_cmd.cpp:190
IsNormalRoadTile
static debug_inline bool IsNormalRoadTile(Tile t)
Return whether a tile is a normal road tile.
Definition road_map.h:74
GetRoadBits
RoadBits GetRoadBits(Tile t, RoadTramType rtt)
Get the present road bits for a specific road type.
Definition road_map.h:128
MayHaveRoad
bool MayHaveRoad(Tile t)
Test whether a tile can have road/tram types.
Definition road_map.h:33
GetAllRoadBits
RoadBits GetAllRoadBits(Tile tile)
Get all set RoadBits on the given tile.
Definition road_map.h:141
GetRoadOwner
Owner GetRoadOwner(Tile t, RoadTramType rtt)
Get the owner of a specific road type.
Definition road_map.h:234
RoadBits
RoadBits
Enumeration for the road parts on a tile.
Definition road_type.h:52
ROAD_Y
@ ROAD_Y
Full road along the y-axis (north-west + south-east)
Definition road_type.h:59
ROAD_X
@ ROAD_X
Full road along the x-axis (south-west + north-east)
Definition road_type.h:58
RoadType
RoadType
The different roadtypes we support.
Definition road_type.h:25
INVALID_ROADTYPE
@ INVALID_ROADTYPE
flag for invalid roadtype
Definition road_type.h:30
safeguards.h
A number of safeguards to prevent using unsafe methods.
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:57
IsSteepSlope
static constexpr bool IsSteepSlope(Slope s)
Checks if a slope is steep.
Definition slope_func.h:36
Slope
Slope
Enumeration for the slope-type.
Definition slope_type.h:48
SLOPE_FLAT
@ SLOPE_FLAT
a flat tile
Definition slope_type.h:49
HasStationInUse
bool HasStationInUse(StationID station, bool include_company, CompanyID company)
Tests whether the company's vehicles have this station in orders.
Definition station_cmd.cpp:2758
SetRailStationTileFlags
void SetRailStationTileFlags(TileIndex tile, const StationSpec *statspec)
Set rail station tile flags for the given tile.
Definition station_cmd.cpp:1322
SetCustomStationSpecIndex
void SetCustomStationSpecIndex(Tile t, uint8_t specindex)
Set the custom station spec for this tile.
Definition station_map.h:630
IsRailWaypointTile
bool IsRailWaypointTile(Tile t)
Is this tile a station tile and a rail waypoint?
Definition station_map.h:123
MakeDriveThroughRoadStop
void MakeDriveThroughRoadStop(Tile t, Owner station, Owner road, Owner tram, StationID sid, StationType rst, RoadType road_rt, RoadType tram_rt, Axis a)
Make the given tile a drivethrough roadstop tile.
Definition station_map.h:795
GetStationIndex
StationID GetStationIndex(Tile t)
Get StationID from a tile.
Definition station_map.h:28
HasStationTileRail
bool HasStationTileRail(Tile t)
Has this station tile a rail? In other words, is this station tile a rail station or rail waypoint?
Definition station_map.h:146
GetCustomStationSpecIndex
uint GetCustomStationSpecIndex(Tile t)
Get the custom station spec for this tile.
Definition station_map.h:642
IsRailWaypoint
bool IsRailWaypoint(Tile t)
Is this station tile a rail waypoint?
Definition station_map.h:113
SetRailStationReservation
void SetRailStationReservation(Tile t, bool b)
Set the reservation state of the rail station.
Definition station_map.h:571
GetRailStationAxis
Axis GetRailStationAxis(Tile t)
Get the rail direction of a rail station.
Definition station_map.h:503
MakeRailWaypoint
void MakeRailWaypoint(Tile t, Owner o, StationID sid, Axis a, uint8_t section, RailType rt)
Make the given tile a rail waypoint tile.
Definition station_map.h:758
IsRoadWaypointTile
bool IsRoadWaypointTile(Tile t)
Is this tile a station tile and a road waypoint?
Definition station_map.h:212
GetDriveThroughStopAxis
Axis GetDriveThroughStopAxis(Tile t)
Gets the axis of the drive through stop.
Definition station_map.h:356
MakeBuoy
void MakeBuoy(Tile t, StationID sid, WaterClass wc)
Make the given tile a buoy tile.
Definition station_map.h:822
HasStationReservation
bool HasStationReservation(Tile t)
Get the reservation state of the rail station.
Definition station_map.h:559
SetCustomRoadStopSpecIndex
void SetCustomRoadStopSpecIndex(Tile t, uint8_t specindex)
Set the custom road stop spec for this tile.
Definition station_map.h:666
FACIL_DOCK
@ FACIL_DOCK
Station with a dock.
Definition station_type.h:58
FACIL_BUS_STOP
@ FACIL_BUS_STOP
Station with bus stops.
Definition station_type.h:56
FACIL_TRUCK_STOP
@ FACIL_TRUCK_STOP
Station with truck stops.
Definition station_type.h:55
FACIL_TRAIN
@ FACIL_TRAIN
Station with train station.
Definition station_type.h:54
StationType
StationType
Station types.
Definition station_type.h:31
MAX_LENGTH_STATION_NAME_CHARS
static const uint MAX_LENGTH_STATION_NAME_CHARS
The maximum length of a station name in characters including '\0'.
Definition station_type.h:87
stdafx.h
Definition of base types and functions in a cross-platform compatible way.
Utf8StringLength
size_t Utf8StringLength(const char *s)
Get the length of an UTF-8 encoded string in number of characters and thus not the number of bytes th...
Definition string.cpp:359
string_func.h
Functions related to low-level strings.
SetDParam
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
Definition strings.cpp:104
strings_func.h
Functions related to OTTD's strings.
StringID
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
Definition strings_type.h:16
INVALID_STRING_ID
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition strings_type.h:17
AnimationInfo::triggers
uint16_t triggers
The triggers that trigger animation.
Definition newgrf_animation_type.h:22
BaseStation
Base class for all station-ish types.
Definition base_station_base.h:59
BaseStation::facilities
StationFacility facilities
The facilities that this station has.
Definition base_station_base.h:70
BaseStation::string_id
StringID string_id
Default name (town area) of station.
Definition base_station_base.h:65
BaseStation::xy
TileIndex xy
Base tile of the station.
Definition base_station_base.h:60
BaseStation::train_station
TileArea train_station
Tile area the train 'station' part covers.
Definition base_station_base.h:84
BaseStation::cached_roadstop_anim_triggers
uint8_t cached_roadstop_anim_triggers
NOSAVE: Combined animation trigger bitmask for road stops, used to determine if trigger processing sh...
Definition base_station_base.h:80
BaseStation::owner
Owner owner
The owner of this station.
Definition base_station_base.h:69
BaseStation::delete_ctr
uint8_t delete_ctr
Delete counter. If greater than 0 then it is decremented until it reaches 0; the waypoint is then is ...
Definition base_station_base.h:62
BaseStation::rect
StationRect rect
NOSAVE: Station spread out rectangle maintained by StationRect::xxx() functions.
Definition base_station_base.h:85
BaseStation::IsInUse
bool IsInUse() const
Check whether the base station currently is in use; in use means that it is not scheduled for deletio...
Definition base_station_base.h:177
BaseStation::town
Town * town
The town this station is associated with.
Definition base_station_base.h:68
BaseStation::GetByTile
static BaseStation * GetByTile(TileIndex tile)
Get the base station belonging to a specific tile.
Definition base_station_base.h:166
BaseStation::sign
TrackedViewportSign sign
NOSAVE: Dimensions of sign.
Definition base_station_base.h:61
BaseStation::build_date
TimerGameCalendar::Date build_date
Date of construction.
Definition base_station_base.h:75
BaseStation::name
std::string name
Custom name.
Definition base_station_base.h:64
CommandHelper
Definition command_func.h:83
CompanyInfrastructure::station
uint32_t station
Count of company owned station tiles.
Definition company_base.h:37
Company
Definition company_base.h:133
Company::infrastructure
CompanyInfrastructure infrastructure
NOSAVE: Counts of company owned infrastructure.
Definition company_base.h:147
ConstructionSettings::build_on_slopes
bool build_on_slopes
allow building on slopes
Definition settings_type.h:383
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition settings_type.h:594
GameSettings::station
StationSettings station
settings related to station management
Definition settings_type.h:604
OrthogonalTileArea
Represents the covered area of e.g.
Definition tilearea_type.h:18
OrthogonalTileArea::Add
void Add(TileIndex to_add)
Add a single tile to a tile area; enlarge if needed.
Definition tilearea.cpp:43
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition tilearea_type.h:19
Point
Coordinates of a point in 2D.
Definition geometry_type.hpp:21
Pool::PoolItem<&_station_pool >::index
Tindex index
Index of this pool item.
Definition pool_type.hpp:238
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition pool_type.hpp:328
Pool::PoolItem<&_station_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition pool_type.hpp:309
Pool::PoolItem<&_company_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition pool_type.hpp:339
RoadStopSpec
Road stop specification.
Definition newgrf_roadstop.h:135
RoadStopSpec::GetBuildCost
Money GetBuildCost(Price category) const
Get the cost for building a road stop of this type.
Definition newgrf_roadstop.h:164
SpecializedStation< Waypoint, true >::Iterate
static Pool::IterateWrapper< Waypoint > Iterate(size_t from=0)
Returns an iterable ensemble of all valid stations of type T.
Definition base_station_base.h:305
SpecializedStation< Waypoint, true >::GetIfValid
static Waypoint * GetIfValid(size_t index)
Returns station if the index is a valid index for this station type.
Definition base_station_base.h:263
SpecializedStation< Waypoint, true >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index is a valid index for station of this type.
Definition base_station_base.h:245
StationSettings::station_spread
uint8_t station_spread
amount a station may spread
Definition settings_type.h:569
StationSettings::distant_join_stations
bool distant_join_stations
allow to join non-adjacent stations
Definition settings_type.h:567
StationSpec
Station specification.
Definition newgrf_station.h:115
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
TrackedViewportSign::UpdatePosition
void UpdatePosition(int center, int top, StringID str, StringID str_small=STR_NULL)
Update the position of the viewport sign.
Definition viewport_type.h:60
TrackedViewportSign::kdtree_valid
bool kdtree_valid
Are the sign data valid for use with the _viewport_sign_kdtree?
Definition viewport_type.h:52
Waypoint
Representation of a waypoint.
Definition waypoint_base.h:23
Waypoint::road_waypoint_area
TileArea road_waypoint_area
Tile area the road waypoint part covers.
Definition waypoint_base.h:26
Waypoint::waypoint_flags
uint16_t waypoint_flags
Waypoint flags, see WaypointFlags.
Definition waypoint_base.h:25
Waypoint::MoveSign
void MoveSign(TileIndex new_xy) override
Move the waypoint main coordinate somewhere else.
Definition waypoint_cmd.cpp:60
Waypoint::UpdateVirtCoord
void UpdateVirtCoord() override
Update the virtual coords needed to draw the waypoint sign.
Definition waypoint_cmd.cpp:42
IsTileFlat
bool IsTileFlat(TileIndex tile, int *h)
Check if a given tile is flat.
Definition tile_map.cpp:95
GetTileOwner
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition tile_map.h:178
IsTileType
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
GetTileSlope
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
Definition tile_map.h:279
TILE_SIZE
static const uint TILE_SIZE
Tile size in world coordinates.
Definition tile_type.h:15
INVALID_TILE
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:95
MP_STATION
@ MP_STATION
A tile of a station.
Definition tile_type.h:53
MP_RAILWAY
@ MP_RAILWAY
A railway.
Definition tile_type.h:49
timer_game_calendar.h
Definition of the game-calendar-timer.
town.h
Base of the town class.
MakeDefaultName
void MakeDefaultName(T *obj)
Set the default name for a depot/waypoint.
Definition town.h:254
AxisToTrack
Track AxisToTrack(Axis a)
Convert an Axis to the corresponding Track AXIS_X -> TRACK_X AXIS_Y -> TRACK_Y Uses the fact that the...
Definition track_func.h:66
TRACK_BIT_Y
@ TRACK_BIT_Y
Y-axis track.
Definition track_type.h:38
TRACK_BIT_X
@ TRACK_BIT_X
X-axis track.
Definition track_type.h:37
EnsureNoVehicleOnGround
CommandCost EnsureNoVehicleOnGround(TileIndex tile)
Ensure there is no vehicle at the ground at the given position.
Definition vehicle.cpp:546
vehicle_func.h
Functions related to vehicles.
viewport_func.h
Functions related to (drawing on) viewports.
water.h
Functions related to water (management)
ClearNeighbourNonFloodingStates
void ClearNeighbourNonFloodingStates(TileIndex tile)
Clear non-flooding state of the tiles around a tile.
Definition water_cmd.cpp:97
CheckForDockingTile
void CheckForDockingTile(TileIndex t)
Mark the supplied tile as a docking tile if it is suitable for docking.
Definition water_cmd.cpp:195
HasTileWaterGround
bool HasTileWaterGround(Tile t)
Checks whether the tile has water at the ground.
Definition water_map.h:350
GetWaterClass
WaterClass GetWaterClass(Tile t)
Get the water class at a tile.
Definition water_map.h:112
IsWaterTile
bool IsWaterTile(Tile t)
Is it a water tile with plain water?
Definition water_map.h:190
water_regions.h
Handles dividing the water in the map into regions to assist pathfinding.
waypoint_base.h
Base of waypoints.
WPF_ROAD
@ WPF_ROAD
This is a road waypoint.
Definition waypoint_base.h:19
IsValidTileForWaypoint
static CommandCost IsValidTileForWaypoint(TileIndex tile, Axis axis, StationID *waypoint)
Check whether the given tile is suitable for a waypoint.
Definition waypoint_cmd.cpp:147
ClearTile_Station
CommandCost ClearTile_Station(TileIndex tile, DoCommandFlag flags)
Clear a single tile of a station.
Definition station_cmd.cpp:4696
CmdBuildRoadWaypoint
CommandCost CmdBuildRoadWaypoint(DoCommandFlag flags, TileIndex start_tile, Axis axis, uint8_t width, uint8_t height, RoadStopClassID spec_class, uint16_t spec_index, StationID station_to_join, bool adjacent)
Build a road waypoint on an existing road.
Definition waypoint_cmd.cpp:335
CanExpandRailStation
CommandCost CanExpandRailStation(const BaseStation *st, TileArea &new_ta)
Check whether we can expand the rail part of the given station.
Definition station_cmd.cpp:1081
GetAxisForNewRailWaypoint
Axis GetAxisForNewRailWaypoint(TileIndex tile)
Get the axis for a new rail waypoint.
Definition waypoint_cmd.cpp:101
GetAxisForNewRoadWaypoint
Axis GetAxisForNewRoadWaypoint(TileIndex tile)
Get the axis for a new road waypoint.
Definition waypoint_cmd.cpp:123
FindJoiningWaypoint
CommandCost FindJoiningWaypoint(StationID existing_station, StationID station_to_join, bool adjacent, TileArea ta, Waypoint **wp, bool is_road)
Find a nearby waypoint that joins this waypoint.
Definition station_cmd.cpp:1222
CmdBuildRailWaypoint
CommandCost CmdBuildRailWaypoint(DoCommandFlag flags, TileIndex start_tile, Axis axis, uint8_t width, uint8_t height, StationClassID spec_class, uint16_t spec_index, StationID station_to_join, bool adjacent)
Convert existing rail to waypoint.
Definition waypoint_cmd.cpp:203
GetStationLayout
void GetStationLayout(uint8_t *layout, uint numtracks, uint plat_len, const StationSpec *statspec)
Create the station layout for the given number of tracks and platform length.
Definition station_cmd.cpp:1126
CmdBuildBuoy
CommandCost CmdBuildBuoy(DoCommandFlag flags, TileIndex tile)
Build a buoy.
Definition waypoint_cmd.cpp:468
IsUniqueWaypointName
static bool IsUniqueWaypointName(const std::string &name)
Check whether the name is unique amongst the waypoints.
Definition waypoint_cmd.cpp:562
FindDeletedWaypointCloseTo
static Waypoint * FindDeletedWaypointCloseTo(TileIndex tile, StringID str, CompanyID cid, bool is_road)
Find a deleted waypoint close to a tile.
Definition waypoint_cmd.cpp:75
RemoveBuoy
CommandCost RemoveBuoy(TileIndex tile, DoCommandFlag flags)
Remove a buoy.
Definition waypoint_cmd.cpp:524
CalculateRoadStopCost
CommandCost CalculateRoadStopCost(TileArea tile_area, DoCommandFlag flags, bool is_drive_through, StationType station_type, Axis axis, DiagDirection ddir, StationID *est, RoadType rt, Money unit_cost)
Calculates cost of new road stops within the area.
Definition station_cmd.cpp:1919
RemoveRoadWaypointStop
CommandCost RemoveRoadWaypointStop(TileIndex tile, DoCommandFlag flags, int replacement_spec_index)
Remove a road waypoint.
Definition station_cmd.cpp:2254
CmdRenameWaypoint
CommandCost CmdRenameWaypoint(DoCommandFlag flags, StationID waypoint_id, const std::string &text)
Rename a waypoint.
Definition waypoint_cmd.cpp:578
waypoint_cmd.h
Command definitions related to waypoints.
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:3219
window_func.h
Window functions not directly related to making/drawing windows.
WC_WAYPOINT_VIEW
@ WC_WAYPOINT_VIEW
Waypoint view; Window numbers:
Definition window_type.h:357
yapf_cache.h
Entry point for OpenTTD to YAPF's cache.
YapfNotifyTrackLayoutChange
void YapfNotifyTrackLayoutChange(TileIndex tile, Track track)
Use this function to notify YAPF that track layout (or signal configuration) has change.
Definition yapf_rail.cpp:639