OpenTTD

- Main Page
- Related Pages
- Modules
- Namespaces
- Data Structures
- Files

- File List
- Globals

rail_cmd.cpp
Go to the documentation of this file.
1 /* $Id: rail_cmd.cpp 27893 2017-08-13 18:38:42Z frosch $ */
2
3 /*
4 * This file is part of OpenTTD.
5 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
6 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
7 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
8 */
9
12 #include "stdafx.h"
13 #include "cmd_helper.h"
14 #include "viewport_func.h"
15 #include "command_func.h"
16 #include "depot_base.h"
17 #include "pathfinder/yapf/yapf_cache.h"
18 #include "newgrf_debug.h"
19 #include "newgrf_railtype.h"
20 #include "train.h"
21 #include "autoslope.h"
22 #include "water.h"
23 #include "tunnelbridge_map.h"
24 #include "vehicle_func.h"
25 #include "sound_func.h"
26 #include "tunnelbridge.h"
27 #include "elrail_func.h"
28 #include "town.h"
29 #include "pbs.h"
30 #include "company_base.h"
31 #include "core/backup_type.hpp"
32 #include "date_func.h"
33 #include "strings_func.h"
34 #include "company_gui.h"
35 #include "object_map.h"
36
37 #include "table/strings.h"
38 #include "table/railtypes.h"
39 #include "table/track_land.h"
40
41 #include "safeguards.h"
42
44 typedef SmallVector<Train *, 16> TrainList;
45
46 RailtypeInfo _railtypes[RAILTYPE_END];
47 RailType _sorted_railtypes[RAILTYPE_END];
48 uint8 _sorted_railtypes_size;
49
51 enum SignalOffsets {
52 SIGNAL_TO_SOUTHWEST,
53 SIGNAL_TO_NORTHEAST,
54 SIGNAL_TO_SOUTHEAST,
55 SIGNAL_TO_NORTHWEST,
56 SIGNAL_TO_EAST,
57 SIGNAL_TO_WEST,
58 SIGNAL_TO_SOUTH,
59 SIGNAL_TO_NORTH,
60 };
61
65 void ResetRailTypes()
66 {
67 assert_compile(lengthof(_original_railtypes) <= lengthof(_railtypes));
68
69 uint i = 0;
70 for (; i < lengthof(_original_railtypes); i++) _railtypes[i] = _original_railtypes[i];
71
72 static const RailtypeInfo empty_railtype = {
73 {0,0,0,0,0,0,0,0,0,0,0,0},
74 {0,0,0,0,0,0,0,0,{}},
75 {0,0,0,0,0,0,0,0},
76 {0,0,0,0,0,0},
77 0, RAILTYPES_NONE, RAILTYPES_NONE, 0, 0, 0, RTFB_NONE, 0, 0, 0, 0, 0,
78 RailTypeLabelList(), 0, 0, RAILTYPES_NONE, RAILTYPES_NONE, 0,
79 {}, {} };
80 for (; i < lengthof(_railtypes); i++) _railtypes[i] = empty_railtype;
81 }
82
83 void ResolveRailTypeGUISprites(RailtypeInfo *rti)
84 {
85 SpriteID cursors_base = GetCustomRailSprite(rti, INVALID_TILE, RTSG_CURSORS);
86 if (cursors_base != 0) {
87 rti->gui_sprites.build_ns_rail = cursors_base + 0;
88 rti->gui_sprites.build_x_rail = cursors_base + 1;
89 rti->gui_sprites.build_ew_rail = cursors_base + 2;
90 rti->gui_sprites.build_y_rail = cursors_base + 3;
91 rti->gui_sprites.auto_rail = cursors_base + 4;
92 rti->gui_sprites.build_depot = cursors_base + 5;
93 rti->gui_sprites.build_tunnel = cursors_base + 6;
94 rti->gui_sprites.convert_rail = cursors_base + 7;
95 rti->cursor.rail_ns = cursors_base + 8;
96 rti->cursor.rail_swne = cursors_base + 9;
97 rti->cursor.rail_ew = cursors_base + 10;
98 rti->cursor.rail_nwse = cursors_base + 11;
99 rti->cursor.autorail = cursors_base + 12;
100 rti->cursor.depot = cursors_base + 13;
101 rti->cursor.tunnel = cursors_base + 14;
102 rti->cursor.convert = cursors_base + 15;
103 }
104
105 /* Array of default GUI signal sprite numbers. */
106 const SpriteID _signal_lookup[2][SIGTYPE_END] = {
107 {SPR_IMG_SIGNAL_ELECTRIC_NORM, SPR_IMG_SIGNAL_ELECTRIC_ENTRY, SPR_IMG_SIGNAL_ELECTRIC_EXIT,
108 SPR_IMG_SIGNAL_ELECTRIC_COMBO, SPR_IMG_SIGNAL_ELECTRIC_PBS, SPR_IMG_SIGNAL_ELECTRIC_PBS_OWAY},
109
110 {SPR_IMG_SIGNAL_SEMAPHORE_NORM, SPR_IMG_SIGNAL_SEMAPHORE_ENTRY, SPR_IMG_SIGNAL_SEMAPHORE_EXIT,
111 SPR_IMG_SIGNAL_SEMAPHORE_COMBO, SPR_IMG_SIGNAL_SEMAPHORE_PBS, SPR_IMG_SIGNAL_SEMAPHORE_PBS_OWAY},
112 };
113
114 for (SignalType type = SIGTYPE_NORMAL; type < SIGTYPE_END; type = (SignalType)(type + 1)) {
115 for (SignalVariant var = SIG_ELECTRIC; var <= SIG_SEMAPHORE; var = (SignalVariant)(var + 1)) {
116 SpriteID red = GetCustomSignalSprite(rti, INVALID_TILE, type, var, SIGNAL_STATE_RED, true);
117 SpriteID green = GetCustomSignalSprite(rti, INVALID_TILE, type, var, SIGNAL_STATE_GREEN, true);
118 rti->gui_sprites.signals[type][var][0] = (red != 0) ? red + SIGNAL_TO_SOUTH : _signal_lookup[var][type];
119 rti->gui_sprites.signals[type][var][1] = (green != 0) ? green + SIGNAL_TO_SOUTH : _signal_lookup[var][type] + 1;
120 }
121 }
122 }
123
130 static int CDECL CompareRailTypes(const RailType *first, const RailType *second)
131 {
132 return GetRailTypeInfo(*first)->sorting_order - GetRailTypeInfo(*second)->sorting_order;
133 }
134
138 void InitRailTypes()
139 {
140 for (RailType rt = RAILTYPE_BEGIN; rt != RAILTYPE_END; rt++) {
141 RailtypeInfo *rti = &_railtypes[rt];
142 ResolveRailTypeGUISprites(rti);
143 }
144
145 _sorted_railtypes_size = 0;
146 for (RailType rt = RAILTYPE_BEGIN; rt != RAILTYPE_END; rt++) {
147 if (_railtypes[rt].label != 0) {
148 _sorted_railtypes[_sorted_railtypes_size++] = rt;
149 }
150 }
151 QSortT(_sorted_railtypes, _sorted_railtypes_size, CompareRailTypes);
152 }
153
157 RailType AllocateRailType(RailTypeLabel label)
158 {
159 for (RailType rt = RAILTYPE_BEGIN; rt != RAILTYPE_END; rt++) {
160 RailtypeInfo *rti = &_railtypes[rt];
161
162 if (rti->label == 0) {
163 /* Set up new rail type */
164 *rti = _original_railtypes[RAILTYPE_RAIL];
165 rti->label = label;
166 rti->alternate_labels.Clear();
167
168 /* Make us compatible with ourself. */
169 rti->powered_railtypes = (RailTypes)(1 << rt);
170 rti->compatible_railtypes = (RailTypes)(1 << rt);
171
172 /* We also introduce ourself. */
173 rti->introduces_railtypes = (RailTypes)(1 << rt);
174
175 /* Default sort order; order of allocation, but with some
176 * offsets so it's easier for NewGRF to pick a spot without
177 * changing the order of other (original) rail types.
178 * The << is so you can place other railtypes in between the
179 * other railtypes, the 7 is to be able to place something
180 * before the first (default) rail type. */
181 rti->sorting_order = rt << 4 | 7;
182 return rt;
183 }
184 }
185
186 return INVALID_RAILTYPE;
187 }
188
189 static const byte _track_sloped_sprites[14] = {
190 14, 15, 22, 13,
191 0, 21, 17, 12,
192 23, 0, 18, 20,
193 19, 16
194 };
195
196
197 /* 4
198 * ---------
199 * |\ /|
200 * | \ 1/ |
201 * | \ / |
202 * | \ / |
203 * 16| \ |32
204 * | / \2 |
205 * | / \ |
206 * | / \ |
207 * |/ \|
208 * ---------
209 * 8
210 */
211
212
213
214 /* MAP2 byte: abcd???? => Signal On? Same coding as map3lo
215 * MAP3LO byte: abcd???? => Signal Exists?
216 * a and b are for diagonals, upper and left,
217 * one for each direction. (ie a == NE->SW, b ==
218 * SW->NE, or v.v., I don't know. b and c are
219 * similar for lower and right.
220 * MAP2 byte: ????abcd => Type of ground.
221 * MAP3LO byte: ????abcd => Type of rail.
222 * MAP5: 00abcdef => rail
223 * 01abcdef => rail w/ signals
224 * 10uuuuuu => unused
225 * 11uuuudd => rail depot
226 */
227
236 static CommandCost EnsureNoTrainOnTrack(TileIndex tile, Track track)
237 {
238 TrackBits rail_bits = TrackToTrackBits(track);
239 return EnsureNoTrainOnTrackBits(tile, rail_bits);
240 }
241
249 static CommandCost CheckTrackCombination(TileIndex tile, TrackBits to_build, uint flags)
250 {
251 if (!IsPlainRail(tile)) return_cmd_error(STR_ERROR_IMPOSSIBLE_TRACK_COMBINATION);
252
253 /* So, we have a tile with tracks on it (and possibly signals). Let's see
254 * what tracks first */
255 TrackBits current = GetTrackBits(tile); // The current track layout.
256 TrackBits future = current | to_build; // The track layout we want to build.
257
258 /* Are we really building something new? */
259 if (current == future) {
260 /* Nothing new is being built */
261 return_cmd_error(STR_ERROR_ALREADY_BUILT);
262 }
263
264 /* Let's see if we may build this */
265 if ((flags & DC_NO_RAIL_OVERLAP) || HasSignals(tile)) {
266 /* If we are not allowed to overlap (flag is on for ai companies or we have
267 * signals on the tile), check that */
268 if (future != TRACK_BIT_HORZ && future != TRACK_BIT_VERT) {
269 return_cmd_error((flags & DC_NO_RAIL_OVERLAP) ? STR_ERROR_IMPOSSIBLE_TRACK_COMBINATION : STR_ERROR_MUST_REMOVE_SIGNALS_FIRST);
270 }
271 }
272 /* Normally, we may overlap and any combination is valid */
273 return CommandCost();
274 }
275
276
278 static const TrackBits _valid_tracks_without_foundation[15] = {
279 TRACK_BIT_ALL,
280 TRACK_BIT_RIGHT,
281 TRACK_BIT_UPPER,
282 TRACK_BIT_X,
283
284 TRACK_BIT_LEFT,
285 TRACK_BIT_NONE,
286 TRACK_BIT_Y,
287 TRACK_BIT_LOWER,
288
289 TRACK_BIT_LOWER,
290 TRACK_BIT_Y,
291 TRACK_BIT_NONE,
292 TRACK_BIT_LEFT,
293
294 TRACK_BIT_X,
295 TRACK_BIT_UPPER,
296 TRACK_BIT_RIGHT,
297 };
298
300 static const TrackBits _valid_tracks_on_leveled_foundation[15] = {
301 TRACK_BIT_NONE,
302 TRACK_BIT_LEFT,
303 TRACK_BIT_LOWER,
304 TRACK_BIT_Y | TRACK_BIT_LOWER | TRACK_BIT_LEFT,
305
306 TRACK_BIT_RIGHT,
307 TRACK_BIT_ALL,
308 TRACK_BIT_X | TRACK_BIT_LOWER | TRACK_BIT_RIGHT,
309 TRACK_BIT_ALL,
310
311 TRACK_BIT_UPPER,
312 TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_LEFT,
313 TRACK_BIT_ALL,
314 TRACK_BIT_ALL,
315
316 TRACK_BIT_Y | TRACK_BIT_UPPER | TRACK_BIT_RIGHT,
317 TRACK_BIT_ALL,
318 TRACK_BIT_ALL
319 };
320
328 Foundation GetRailFoundation(Slope tileh, TrackBits bits)
329 {
330 if (bits == TRACK_BIT_NONE) return FOUNDATION_NONE;
331
332 if (IsSteepSlope(tileh)) {
333 /* Test for inclined foundations */
334 if (bits == TRACK_BIT_X) return FOUNDATION_INCLINED_X;
335 if (bits == TRACK_BIT_Y) return FOUNDATION_INCLINED_Y;
336
337 /* Get higher track */
338 Corner highest_corner = GetHighestSlopeCorner(tileh);
339 TrackBits higher_track = CornerToTrackBits(highest_corner);
340
341 /* Only higher track? */
342 if (bits == higher_track) return HalftileFoundation(highest_corner);
343
344 /* Overlap with higher track? */
345 if (TracksOverlap(bits | higher_track)) return FOUNDATION_INVALID;
346
347 /* either lower track or both higher and lower track */
348 return ((bits & higher_track) != 0 ? FOUNDATION_STEEP_BOTH : FOUNDATION_STEEP_LOWER);
349 } else {
350 if ((~_valid_tracks_without_foundation[tileh] & bits) == 0) return FOUNDATION_NONE;
351
352 bool valid_on_leveled = ((~_valid_tracks_on_leveled_foundation[tileh] & bits) == 0);
353
354 Corner track_corner;
355 switch (bits) {
356 case TRACK_BIT_LEFT: track_corner = CORNER_W; break;
357 case TRACK_BIT_LOWER: track_corner = CORNER_S; break;
358 case TRACK_BIT_RIGHT: track_corner = CORNER_E; break;
359 case TRACK_BIT_UPPER: track_corner = CORNER_N; break;
360
361 case TRACK_BIT_HORZ:
362 if (tileh == SLOPE_N) return HalftileFoundation(CORNER_N);
363 if (tileh == SLOPE_S) return HalftileFoundation(CORNER_S);
364 return (valid_on_leveled ? FOUNDATION_LEVELED : FOUNDATION_INVALID);
365
366 case TRACK_BIT_VERT:
367 if (tileh == SLOPE_W) return HalftileFoundation(CORNER_W);
368 if (tileh == SLOPE_E) return HalftileFoundation(CORNER_E);
369 return (valid_on_leveled ? FOUNDATION_LEVELED : FOUNDATION_INVALID);
370
371 case TRACK_BIT_X:
372 if (IsSlopeWithOneCornerRaised(tileh)) return FOUNDATION_INCLINED_X;
373 return (valid_on_leveled ? FOUNDATION_LEVELED : FOUNDATION_INVALID);
374
375 case TRACK_BIT_Y:
376 if (IsSlopeWithOneCornerRaised(tileh)) return FOUNDATION_INCLINED_Y;
377 return (valid_on_leveled ? FOUNDATION_LEVELED : FOUNDATION_INVALID);
378
379 default:
380 return (valid_on_leveled ? FOUNDATION_LEVELED : FOUNDATION_INVALID);
381 }
382 /* Single diagonal track */
383
384 /* Track must be at least valid on leveled foundation */
385 if (!valid_on_leveled) return FOUNDATION_INVALID;
386
387 /* If slope has three raised corners, build leveled foundation */
388 if (IsSlopeWithThreeCornersRaised(tileh)) return FOUNDATION_LEVELED;
389
390 /* If neighboured corners of track_corner are lowered, build halftile foundation */
391 if ((tileh & SlopeWithThreeCornersRaised(OppositeCorner(track_corner))) == SlopeWithOneCornerRaised(track_corner)) return HalftileFoundation(track_corner);
392
393 /* else special anti-zig-zag foundation */
394 return SpecialRailFoundation(track_corner);
395 }
396 }
397
398
408 static CommandCost CheckRailSlope(Slope tileh, TrackBits rail_bits, TrackBits existing, TileIndex tile)
409 {
410 /* don't allow building on the lower side of a coast */
411 if (GetFloodingBehaviour(tile) != FLOOD_NONE) {
412 if (!IsSteepSlope(tileh) && ((~_valid_tracks_on_leveled_foundation[tileh] & (rail_bits | existing)) != 0)) return_cmd_error(STR_ERROR_CAN_T_BUILD_ON_WATER);
413 }
414
415 Foundation f_new = GetRailFoundation(tileh, rail_bits | existing);
416
417 /* check track/slope combination */
418 if ((f_new == FOUNDATION_INVALID) ||
419 ((f_new != FOUNDATION_NONE) && (!_settings_game.construction.build_on_slopes))) {
420 return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
421 }
422
423 Foundation f_old = GetRailFoundation(tileh, existing);
424 return CommandCost(EXPENSES_CONSTRUCTION, f_new != f_old ? _price[PR_BUILD_FOUNDATION] : (Money)0);
425 }
426
427 /* Validate functions for rail building */
428 static inline bool ValParamTrackOrientation(Track track)
429 {
430 return IsValidTrack(track);
431 }
432
442 CommandCost CmdBuildSingleRail(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
443 {
444 RailType railtype = Extract<RailType, 0, 4>(p1);
445 Track track = Extract<Track, 0, 3>(p2);
446 CommandCost cost(EXPENSES_CONSTRUCTION);
447
448 if (!ValParamRailtype(railtype) || !ValParamTrackOrientation(track)) return CMD_ERROR;
449
450 Slope tileh = GetTileSlope(tile);
451 TrackBits trackbit = TrackToTrackBits(track);
452
453 switch (GetTileType(tile)) {
454 case MP_RAILWAY: {
455 CommandCost ret = CheckTileOwnership(tile);
456 if (ret.Failed()) return ret;
457
458 if (!IsPlainRail(tile)) return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR); // just get appropriate error message
459
460 if (!IsCompatibleRail(GetRailType(tile), railtype)) return_cmd_error(STR_ERROR_IMPOSSIBLE_TRACK_COMBINATION);
461
462 ret = CheckTrackCombination(tile, trackbit, flags);
463 if (ret.Succeeded()) ret = EnsureNoTrainOnTrack(tile, track);
464 if (ret.Failed()) return ret;
465
466 ret = CheckRailSlope(tileh, trackbit, GetTrackBits(tile), tile);
467 if (ret.Failed()) return ret;
468 cost.AddCost(ret);
469
470 /* If the rail types don't match, try to convert only if engines of
471 * the new rail type are not powered on the present rail type and engines of
472 * the present rail type are powered on the new rail type. */
473 if (GetRailType(tile) != railtype && !HasPowerOnRail(railtype, GetRailType(tile))) {
474 if (HasPowerOnRail(GetRailType(tile), railtype)) {
475 ret = DoCommand(tile, tile, railtype, flags, CMD_CONVERT_RAIL);
476 if (ret.Failed()) return ret;
477 cost.AddCost(ret);
478 } else {
479 return CMD_ERROR;
480 }
481 }
482
483 if (flags & DC_EXEC) {
484 SetRailGroundType(tile, RAIL_GROUND_BARREN);
485 TrackBits bits = GetTrackBits(tile);
486 SetTrackBits(tile, bits | trackbit);
487 /* Subtract old infrastructure count. */
488 uint pieces = CountBits(bits);
489 if (TracksOverlap(bits)) pieces *= pieces;
490 Company::Get(GetTileOwner(tile))->infrastructure.rail[GetRailType(tile)] -= pieces;
491 /* Add new infrastructure count. */
492 pieces = CountBits(bits | trackbit);
493 if (TracksOverlap(bits | trackbit)) pieces *= pieces;
494 Company::Get(GetTileOwner(tile))->infrastructure.rail[GetRailType(tile)] += pieces;
495 DirtyCompanyInfrastructureWindows(GetTileOwner(tile));
496 }
497 break;
498 }
499
500 case MP_ROAD: {
501 /* Level crossings may only be built on these slopes */
502 if (!HasBit(VALID_LEVEL_CROSSING_SLOPES, tileh)) return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
503
504 CommandCost ret = EnsureNoVehicleOnGround(tile);
505 if (ret.Failed()) return ret;
506
507 if (IsNormalRoad(tile)) {
508 if (HasRoadWorks(tile)) return_cmd_error(STR_ERROR_ROAD_WORKS_IN_PROGRESS);
509
510 if (GetDisallowedRoadDirections(tile) != DRD_NONE) return_cmd_error(STR_ERROR_CROSSING_ON_ONEWAY_ROAD);
511
512 if (RailNoLevelCrossings(railtype)) return_cmd_error(STR_ERROR_CROSSING_DISALLOWED);
513
514 RoadTypes roadtypes = GetRoadTypes(tile);
515 RoadBits road = GetRoadBits(tile, ROADTYPE_ROAD);
516 RoadBits tram = GetRoadBits(tile, ROADTYPE_TRAM);
517 if ((track == TRACK_X && ((road | tram) & ROAD_X) == 0) ||
518 (track == TRACK_Y && ((road | tram) & ROAD_Y) == 0)) {
519 Owner road_owner = GetRoadOwner(tile, ROADTYPE_ROAD);
520 Owner tram_owner = GetRoadOwner(tile, ROADTYPE_TRAM);
521 /* Disallow breaking end-of-line of someone else
522 * so trams can still reverse on this tile. */
523 if (Company::IsValidID(tram_owner) && HasExactlyOneBit(tram)) {
524 CommandCost ret = CheckOwnership(tram_owner);
525 if (ret.Failed()) return ret;
526 }
527 /* Crossings must always have a road... */
528 uint num_new_road_pieces = 2 - CountBits(road);
529 if (road == ROAD_NONE) road_owner = _current_company;
530 roadtypes |= ROADTYPES_ROAD;
531 /* ...but tram is not required. */
532 uint num_new_tram_pieces = (tram != ROAD_NONE) ? 2 - CountBits(tram) : 0;
533
534 cost.AddCost((num_new_road_pieces + num_new_tram_pieces) * _price[PR_BUILD_ROAD]);
535
536 if (flags & DC_EXEC) {
537 MakeRoadCrossing(tile, road_owner, tram_owner, _current_company, (track == TRACK_X ? AXIS_Y : AXIS_X), railtype, roadtypes, GetTownIndex(tile));
538 UpdateLevelCrossing(tile, false);
539 Company::Get(_current_company)->infrastructure.rail[railtype] += LEVELCROSSING_TRACKBIT_FACTOR;
540 DirtyCompanyInfrastructureWindows(_current_company);
541 if (num_new_road_pieces > 0 && Company::IsValidID(road_owner)) {
542 Company::Get(road_owner)->infrastructure.road[ROADTYPE_ROAD] += num_new_road_pieces;
543 DirtyCompanyInfrastructureWindows(road_owner);
544 }
545 if (num_new_tram_pieces > 0 && Company::IsValidID(tram_owner)) {
546 Company::Get(tram_owner)->infrastructure.road[ROADTYPE_TRAM] += num_new_tram_pieces;
547 DirtyCompanyInfrastructureWindows(tram_owner);
548 }
549 }
550 break;
551 }
552 }
553
554 if (IsLevelCrossing(tile) && GetCrossingRailBits(tile) == trackbit) {
555 return_cmd_error(STR_ERROR_ALREADY_BUILT);
556 }
557 }
558 FALLTHROUGH;
559
560 default: {
561 /* Will there be flat water on the lower halftile? */
562 bool water_ground = IsTileType(tile, MP_WATER) && IsSlopeWithOneCornerRaised(tileh);
563
564 CommandCost ret = CheckRailSlope(tileh, trackbit, TRACK_BIT_NONE, tile);
565 if (ret.Failed()) return ret;
566 cost.AddCost(ret);
567
568 ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
569 if (ret.Failed()) return ret;
570 cost.AddCost(ret);
571
572 if (water_ground) {
573 cost.AddCost(-_price[PR_CLEAR_WATER]);
574 cost.AddCost(_price[PR_CLEAR_ROUGH]);
575 }
576
577 if (flags & DC_EXEC) {
578 MakeRailNormal(tile, _current_company, trackbit, railtype);
579 if (water_ground) SetRailGroundType(tile, RAIL_GROUND_WATER);
580 Company::Get(_current_company)->infrastructure.rail[railtype]++;
581 DirtyCompanyInfrastructureWindows(_current_company);
582 }
583 break;
584 }
585 }
586
587 if (flags & DC_EXEC) {
588 MarkTileDirtyByTile(tile);
589 AddTrackToSignalBuffer(tile, track, _current_company);
590 YapfNotifyTrackLayoutChange(tile, track);
591 }
592
593 cost.AddCost(RailBuildCost(railtype));
594 return cost;
595 }
596
606 CommandCost CmdRemoveSingleRail(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
607 {
608 Track track = Extract<Track, 0, 3>(p2);
609 CommandCost cost(EXPENSES_CONSTRUCTION);
610 bool crossing = false;
611
612 if (!ValParamTrackOrientation(track)) return CMD_ERROR;
613 TrackBits trackbit = TrackToTrackBits(track);
614
615 /* Need to read tile owner now because it may change when the rail is removed
616 * Also, in case of floods, _current_company != owner
617 * There may be invalid tiletype even in exec run (when removing long track),
618 * so do not call GetTileOwner(tile) in any case here */
619 Owner owner = INVALID_OWNER;
620
621 Train *v = NULL;
622
623 switch (GetTileType(tile)) {
624 case MP_ROAD: {
625 if (!IsLevelCrossing(tile) || GetCrossingRailBits(tile) != trackbit) return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
626
627 if (_current_company != OWNER_WATER) {
628 CommandCost ret = CheckTileOwnership(tile);
629 if (ret.Failed()) return ret;
630 }
631
632 if (!(flags & DC_BANKRUPT)) {
633 CommandCost ret = EnsureNoVehicleOnGround(tile);
634 if (ret.Failed()) return ret;
635 }
636
637 cost.AddCost(RailClearCost(GetRailType(tile)));
638
639 if (flags & DC_EXEC) {
640 if (HasReservedTracks(tile, trackbit)) {
641 v = GetTrainForReservation(tile, track);
642 if (v != NULL) FreeTrainTrackReservation(v);
643 }
644 owner = GetTileOwner(tile);
645 Company::Get(owner)->infrastructure.rail[GetRailType(tile)] -= LEVELCROSSING_TRACKBIT_FACTOR;
646 DirtyCompanyInfrastructureWindows(owner);
647 MakeRoadNormal(tile, GetCrossingRoadBits(tile), GetRoadTypes(tile), GetTownIndex(tile), GetRoadOwner(tile, ROADTYPE_ROAD), GetRoadOwner(tile, ROADTYPE_TRAM));
648 DeleteNewGRFInspectWindow(GSF_RAILTYPES, tile);
649 }
650 break;
651 }
652
653 case MP_RAILWAY: {
654 TrackBits present;
655 /* There are no rails present at depots. */
656 if (!IsPlainRail(tile)) return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
657
658 if (_current_company != OWNER_WATER) {
659 CommandCost ret = CheckTileOwnership(tile);
660 if (ret.Failed()) return ret;
661 }
662
663 CommandCost ret = EnsureNoTrainOnTrack(tile, track);
664 if (ret.Failed()) return ret;
665
666 present = GetTrackBits(tile);
667 if ((present & trackbit) == 0) return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
668 if (present == (TRACK_BIT_X | TRACK_BIT_Y)) crossing = true;
669
670 cost.AddCost(RailClearCost(GetRailType(tile)));
671
672 /* Charge extra to remove signals on the track, if they are there */
673 if (HasSignalOnTrack(tile, track)) {
674 cost.AddCost(DoCommand(tile, track, 0, flags, CMD_REMOVE_SIGNALS));
675 }
676
677 if (flags & DC_EXEC) {
678 if (HasReservedTracks(tile, trackbit)) {
679 v = GetTrainForReservation(tile, track);
680 if (v != NULL) FreeTrainTrackReservation(v);
681 }
682
683 owner = GetTileOwner(tile);
684
685 /* Subtract old infrastructure count. */
686 uint pieces = CountBits(present);
687 if (TracksOverlap(present)) pieces *= pieces;
688 Company::Get(owner)->infrastructure.rail[GetRailType(tile)] -= pieces;
689 /* Add new infrastructure count. */
690 present ^= trackbit;
691 pieces = CountBits(present);
692 if (TracksOverlap(present)) pieces *= pieces;
693 Company::Get(owner)->infrastructure.rail[GetRailType(tile)] += pieces;
694 DirtyCompanyInfrastructureWindows(owner);
695
696 if (present == 0) {
697 Slope tileh = GetTileSlope(tile);
698 /* If there is flat water on the lower halftile, convert the tile to shore so the water remains */
699 if (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh)) {
700 MakeShore(tile);
701 } else {
702 DoClearSquare(tile);
703 }
704 DeleteNewGRFInspectWindow(GSF_RAILTYPES, tile);
705 } else {
706 SetTrackBits(tile, present);
707 SetTrackReservation(tile, GetRailReservationTrackBits(tile) & present);
708 }
709 }
710 break;
711 }
712
713 default: return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
714 }
715
716 if (flags & DC_EXEC) {
717 /* if we got that far, 'owner' variable is set correctly */
718 assert(Company::IsValidID(owner));
719
720 MarkTileDirtyByTile(tile);
721 if (crossing) {
722 /* crossing is set when only TRACK_BIT_X and TRACK_BIT_Y are set. As we
723 * are removing one of these pieces, we'll need to update signals for
724 * both directions explicitly, as after the track is removed it won't
725 * 'connect' with the other piece. */
726 AddTrackToSignalBuffer(tile, TRACK_X, owner);
727 AddTrackToSignalBuffer(tile, TRACK_Y, owner);
728 YapfNotifyTrackLayoutChange(tile, TRACK_X);
729 YapfNotifyTrackLayoutChange(tile, TRACK_Y);
730 } else {
731 AddTrackToSignalBuffer(tile, track, owner);
732 YapfNotifyTrackLayoutChange(tile, track);
733 }
734
735 if (v != NULL) TryPathReserve(v, true);
736 }
737
738 return cost;
739 }
740
741
749 bool FloodHalftile(TileIndex t)
750 {
751 assert(IsPlainRailTile(t));
752
753 bool flooded = false;
754 if (GetRailGroundType(t) == RAIL_GROUND_WATER) return flooded;
755
756 Slope tileh = GetTileSlope(t);
757 TrackBits rail_bits = GetTrackBits(t);
758
759 if (IsSlopeWithOneCornerRaised(tileh)) {
760 TrackBits lower_track = CornerToTrackBits(OppositeCorner(GetHighestSlopeCorner(tileh)));
761
762 TrackBits to_remove = lower_track & rail_bits;
763 if (to_remove != 0) {
764 Backup<CompanyByte> cur_company(_current_company, OWNER_WATER, FILE_LINE);
765 flooded = DoCommand(t, 0, FIND_FIRST_BIT(to_remove), DC_EXEC, CMD_REMOVE_SINGLE_RAIL).Succeeded();
766 cur_company.Restore();
767 if (!flooded) return flooded; // not yet floodable
768 rail_bits = rail_bits & ~to_remove;
769 if (rail_bits == 0) {
770 MakeShore(t);
771 MarkTileDirtyByTile(t);
772 return flooded;
773 }
774 }
775
776 if (IsNonContinuousFoundation(GetRailFoundation(tileh, rail_bits))) {
777 flooded = true;
778 SetRailGroundType(t, RAIL_GROUND_WATER);
779 MarkTileDirtyByTile(t);
780 }
781 } else {
782 /* Make shore on steep slopes and 'three-corners-raised'-slopes. */
783 if (ApplyFoundationToSlope(GetRailFoundation(tileh, rail_bits), &tileh) == 0) {
784 if (IsSteepSlope(tileh) || IsSlopeWithThreeCornersRaised(tileh)) {
785 flooded = true;
786 SetRailGroundType(t, RAIL_GROUND_WATER);
787 MarkTileDirtyByTile(t);
788 }
789 }
790 }
791 return flooded;
792 }
793
794 static const TileIndexDiffC _trackdelta[] = {
795 { -1, 0 }, { 0, 1 }, { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, 1 },
796 { 0, 0 },
797 { 0, 0 },
798 { 1, 0 }, { 0, -1 }, { 0, -1 }, { 1, 0 }, { 0, -1 }, { -1, 0 },
799 { 0, 0 },
800 { 0, 0 }
801 };
802
803
804 static CommandCost ValidateAutoDrag(Trackdir *trackdir, TileIndex start, TileIndex end)
805 {
806 int x = TileX(start);
807 int y = TileY(start);
808 int ex = TileX(end);
809 int ey = TileY(end);
810
811 if (!ValParamTrackOrientation(TrackdirToTrack(*trackdir))) return CMD_ERROR;
812
813 /* calculate delta x,y from start to end tile */
814 int dx = ex - x;
815 int dy = ey - y;
816
817 /* calculate delta x,y for the first direction */
818 int trdx = _trackdelta[*trackdir].x;
819 int trdy = _trackdelta[*trackdir].y;
820
821 if (!IsDiagonalTrackdir(*trackdir)) {
822 trdx += _trackdelta[*trackdir ^ 1].x;
823 trdy += _trackdelta[*trackdir ^ 1].y;
824 }
825
826 /* validate the direction */
827 while ((trdx <= 0 && dx > 0) ||
828 (trdx >= 0 && dx < 0) ||
829 (trdy <= 0 && dy > 0) ||
830 (trdy >= 0 && dy < 0)) {
831 if (!HasBit(*trackdir, 3)) { // first direction is invalid, try the other
832 SetBit(*trackdir, 3); // reverse the direction
833 trdx = -trdx;
834 trdy = -trdy;
835 } else { // other direction is invalid too, invalid drag
836 return CMD_ERROR;
837 }
838 }
839
840 /* (for diagonal tracks, this is already made sure of by above test), but:
841 * for non-diagonal tracks, check if the start and end tile are on 1 line */
842 if (!IsDiagonalTrackdir(*trackdir)) {
843 trdx = _trackdelta[*trackdir].x;
844 trdy = _trackdelta[*trackdir].y;
845 if (abs(dx) != abs(dy) && abs(dx) + abs(trdy) != abs(dy) + abs(trdx)) return CMD_ERROR;
846 }
847
848 return CommandCost();
849 }
850
864 static CommandCost CmdRailTrackHelper(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
865 {
866 CommandCost total_cost(EXPENSES_CONSTRUCTION);
867 Track track = Extract<Track, 4, 3>(p2);
868 bool remove = HasBit(p2, 7);
869 RailType railtype = Extract<RailType, 0, 4>(p2);
870
871 if ((!remove && !ValParamRailtype(railtype)) || !ValParamTrackOrientation(track)) return CMD_ERROR;
872 if (p1 >= MapSize()) return CMD_ERROR;
873 TileIndex end_tile = p1;
874 Trackdir trackdir = TrackToTrackdir(track);
875
876 CommandCost ret = ValidateAutoDrag(&trackdir, tile, end_tile);
877 if (ret.Failed()) return ret;
878
879 bool had_success = false;
880 CommandCost last_error = CMD_ERROR;
881 for (;;) {
882 CommandCost ret = DoCommand(tile, remove ? 0 : railtype, TrackdirToTrack(trackdir), flags, remove ? CMD_REMOVE_SINGLE_RAIL : CMD_BUILD_SINGLE_RAIL);
883
884 if (ret.Failed()) {
885 last_error = ret;
886 if (last_error.GetErrorMessage() != STR_ERROR_ALREADY_BUILT && !remove) {
887 if (HasBit(p2, 8)) return last_error;
888 break;
889 }
890
891 /* Ownership errors are more important. */
892 if (last_error.GetErrorMessage() == STR_ERROR_OWNED_BY && remove) break;
893 } else {
894 had_success = true;
895 total_cost.AddCost(ret);
896 }
897
898 if (tile == end_tile) break;
899
900 tile += ToTileIndexDiff(_trackdelta[trackdir]);
901
902 /* toggle railbit for the non-diagonal tracks */
903 if (!IsDiagonalTrackdir(trackdir)) ToggleBit(trackdir, 0);
904 }
905
906 if (had_success) return total_cost;
907 return last_error;
908 }
909
924 CommandCost CmdBuildRailroadTrack(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
925 {
926 return CmdRailTrackHelper(tile, flags, p1, ClrBit(p2, 7), text);
927 }
928
943 CommandCost CmdRemoveRailroadTrack(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
944 {
945 return CmdRailTrackHelper(tile, flags, p1, SetBit(p2, 7), text);
946 }
947
960 CommandCost CmdBuildTrainDepot(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
961 {
962 /* check railtype and valid direction for depot (0 through 3), 4 in total */
963 RailType railtype = Extract<RailType, 0, 4>(p1);
964 if (!ValParamRailtype(railtype)) return CMD_ERROR;
965
966 Slope tileh = GetTileSlope(tile);
967
968 DiagDirection dir = Extract<DiagDirection, 0, 2>(p2);
969
970 /* Prohibit construction if
971 * The tile is non-flat AND
972 * 1) build-on-slopes is disabled
973 * 2) the tile is steep i.e. spans two height levels
974 * 3) the exit points in the wrong direction
975 */
976
977 if (tileh != SLOPE_FLAT && (
978 !_settings_game.construction.build_on_slopes ||
979 !CanBuildDepotByTileh(dir, tileh)
980 )) {
981 return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED);
982 }
983
984 CommandCost cost = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
985 if (cost.Failed()) return cost;
986
987 if (IsBridgeAbove(tile)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
988
989 if (!Depot::CanAllocateItem()) return CMD_ERROR;
990
991 if (flags & DC_EXEC) {
992 Depot *d = new Depot(tile);
993 d->build_date = _date;
994
995 MakeRailDepot(tile, _current_company, d->index, dir, railtype);
996 MarkTileDirtyByTile(tile);
997 MakeDefaultName(d);
998
999 Company::Get(_current_company)->infrastructure.rail[railtype]++;
1000 DirtyCompanyInfrastructureWindows(_current_company);
1001
1002 AddSideToSignalBuffer(tile, INVALID_DIAGDIR, _current_company);
1003 YapfNotifyTrackLayoutChange(tile, DiagDirToDiagTrack(dir));
1004 }
1005
1006 cost.AddCost(_price[PR_BUILD_DEPOT_TRAIN]);
1007 cost.AddCost(RailBuildCost(railtype));
1008 return cost;
1009 }
1010
1032 CommandCost CmdBuildSingleSignal(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
1033 {
1034 Track track = Extract<Track, 0, 3>(p1);
1035 bool ctrl_pressed = HasBit(p1, 3); // was the CTRL button pressed
1036 SignalVariant sigvar = (ctrl_pressed ^ HasBit(p1, 4)) ? SIG_SEMAPHORE : SIG_ELECTRIC; // the signal variant of the new signal
1037 SignalType sigtype = Extract<SignalType, 5, 3>(p1); // the signal type of the new signal
1038 bool convert_signal = HasBit(p1, 8); // convert button pressed
1039 SignalType cycle_start = Extract<SignalType, 9, 3>(p1);
1040 SignalType cycle_stop = Extract<SignalType, 12, 3>(p1);
1041 uint num_dir_cycle = GB(p1, 15, 2);
1042
1043 if (sigtype > SIGTYPE_LAST) return CMD_ERROR;
1044 if (cycle_start > cycle_stop || cycle_stop > SIGTYPE_LAST) return CMD_ERROR;
1045
1046 /* You can only build signals on plain rail tiles, and the selected track must exist */
1047 if (!ValParamTrackOrientation(track) || !IsPlainRailTile(tile) ||
1048 !HasTrack(tile, track)) {
1049 return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
1050 }
1051 /* Protect against invalid signal copying */
1052 if (p2 != 0 && (p2 & SignalOnTrack(track)) == 0) return CMD_ERROR;
1053
1054 CommandCost ret = CheckTileOwnership(tile);
1055 if (ret.Failed()) return ret;
1056
1057 /* See if this is a valid track combination for signals (no overlap) */
1058 if (TracksOverlap(GetTrackBits(tile))) return_cmd_error(STR_ERROR_NO_SUITABLE_RAILROAD_TRACK);
1059
1060 /* In case we don't want to change an existing signal, return without error. */
1061 if (HasBit(p1, 17) && HasSignalOnTrack(tile, track)) return CommandCost();
1062
1063 /* you can not convert a signal if no signal is on track */
1064 if (convert_signal && !HasSignalOnTrack(tile, track)) return_cmd_error(STR_ERROR_THERE_ARE_NO_SIGNALS);
1065
1066 CommandCost cost;
1067 if (!HasSignalOnTrack(tile, track)) {
1068 /* build new signals */
1069 cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_SIGNALS]);
1070 } else {
1071 if (p2 != 0 && sigvar != GetSignalVariant(tile, track)) {
1072 /* convert signals <-> semaphores */
1073 cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_SIGNALS] + _price[PR_CLEAR_SIGNALS]);
1074
1075 } else if (convert_signal) {
1076 /* convert button pressed */
1077 if (ctrl_pressed || GetSignalVariant(tile, track) != sigvar) {
1078 /* convert electric <-> semaphore */
1079 cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_SIGNALS] + _price[PR_CLEAR_SIGNALS]);
1080 } else {
1081 /* it is free to change signal type: normal-pre-exit-combo */
1082 cost = CommandCost();
1083 }
1084
1085 } else {
1086 /* it is free to change orientation/pre-exit-combo signals */
1087 cost = CommandCost();
1088 }
1089 }
1090
1091 if (flags & DC_EXEC) {
1092 Train *v = NULL;
1093 /* The new/changed signal could block our path. As this can lead to
1094 * stale reservations, we clear the path reservation here and try
1095 * to redo it later on. */
1096 if (HasReservedTracks(tile, TrackToTrackBits(track))) {
1097 v = GetTrainForReservation(tile, track);
1098 if (v != NULL) FreeTrainTrackReservation(v);
1099 }
1100
1101 if (!HasSignals(tile)) {
1102 /* there are no signals at all on this tile yet */
1103 SetHasSignals(tile, true);
1104 SetSignalStates(tile, 0xF); // all signals are on
1105 SetPresentSignals(tile, 0); // no signals built by default
1106 SetSignalType(tile, track, sigtype);
1107 SetSignalVariant(tile, track, sigvar);
1108 }
1109
1110 /* Subtract old signal infrastructure count. */
1111 Company::Get(GetTileOwner(tile))->infrastructure.signal -= CountBits(GetPresentSignals(tile));
1112
1113 if (p2 == 0) {
1114 if (!HasSignalOnTrack(tile, track)) {
1115 /* build new signals */
1116 SetPresentSignals(tile, GetPresentSignals(tile) | (IsPbsSignal(sigtype) ? KillFirstBit(SignalOnTrack(track)) : SignalOnTrack(track)));
1117 SetSignalType(tile, track, sigtype);
1118 SetSignalVariant(tile, track, sigvar);
1119 while (num_dir_cycle-- > 0) CycleSignalSide(tile, track);
1120 } else {
1121 if (convert_signal) {
1122 /* convert signal button pressed */
1123 if (ctrl_pressed) {
1124 /* toggle the present signal variant: SIG_ELECTRIC <-> SIG_SEMAPHORE */
1125 SetSignalVariant(tile, track, (GetSignalVariant(tile, track) == SIG_ELECTRIC) ? SIG_SEMAPHORE : SIG_ELECTRIC);
1126 /* Query current signal type so the check for PBS signals below works. */
1127 sigtype = GetSignalType(tile, track);
1128 } else {
1129 /* convert the present signal to the chosen type and variant */
1130 SetSignalType(tile, track, sigtype);
1131 SetSignalVariant(tile, track, sigvar);
1132 if (IsPbsSignal(sigtype) && (GetPresentSignals(tile) & SignalOnTrack(track)) == SignalOnTrack(track)) {
1133 SetPresentSignals(tile, (GetPresentSignals(tile) & ~SignalOnTrack(track)) | KillFirstBit(SignalOnTrack(track)));
1134 }
1135 }
1136
1137 } else if (ctrl_pressed) {
1138 /* cycle between cycle_start and cycle_end */
1139 sigtype = (SignalType)(GetSignalType(tile, track) + 1);
1140
1141 if (sigtype < cycle_start || sigtype > cycle_stop) sigtype = cycle_start;
1142
1143 SetSignalType(tile, track, sigtype);
1144 if (IsPbsSignal(sigtype) && (GetPresentSignals(tile) & SignalOnTrack(track)) == SignalOnTrack(track)) {
1145 SetPresentSignals(tile, (GetPresentSignals(tile) & ~SignalOnTrack(track)) | KillFirstBit(SignalOnTrack(track)));
1146 }
1147 } else {
1148 /* cycle the signal side: both -> left -> right -> both -> ... */
1149 CycleSignalSide(tile, track);
1150 /* Query current signal type so the check for PBS signals below works. */
1151 sigtype = GetSignalType(tile, track);
1152 }
1153 }
1154 } else {
1155 /* If CmdBuildManySignals is called with copying signals, just copy the
1156 * direction of the first signal given as parameter by CmdBuildManySignals */
1157 SetPresentSignals(tile, (GetPresentSignals(tile) & ~SignalOnTrack(track)) | (p2 & SignalOnTrack(track)));
1158 SetSignalVariant(tile, track, sigvar);
1159 SetSignalType(tile, track, sigtype);
1160 }
1161
1162 /* Add new signal infrastructure count. */
1163 Company::Get(GetTileOwner(tile))->infrastructure.signal += CountBits(GetPresentSignals(tile));
1164 DirtyCompanyInfrastructureWindows(GetTileOwner(tile));
1165
1166 if (IsPbsSignal(sigtype)) {
1167 /* PBS signals should show red unless they are on reserved tiles without a train. */
1168 uint mask = GetPresentSignals(tile) & SignalOnTrack(track);
1169 SetSignalStates(tile, (GetSignalStates(tile) & ~mask) | ((HasBit(GetRailReservationTrackBits(tile), track) && EnsureNoVehicleOnGround(tile).Succeeded() ? UINT_MAX : 0) & mask));
1170 }
1171 MarkTileDirtyByTile(tile);
1172 AddTrackToSignalBuffer(tile, track, _current_company);
1173 YapfNotifyTrackLayoutChange(tile, track);
1174 if (v != NULL) {
1175 /* Extend the train's path if it's not stopped or loading, or not at a safe position. */
1176 if (!(((v->vehstatus & VS_STOPPED) && v->cur_speed == 0) || v->current_order.IsType(OT_LOADING)) ||
1177 !IsSafeWaitingPosition(v, v->tile, v->GetVehicleTrackdir(), true, _settings_game.pf.forbid_90_deg)) {
1178 TryPathReserve(v, true);
1179 }
1180 }
1181 }
1182
1183 return cost;
1184 }
1185
1186 static bool CheckSignalAutoFill(TileIndex &tile, Trackdir &trackdir, int &signal_ctr, bool remove)
1187 {
1188 tile = AddTileIndexDiffCWrap(tile, _trackdelta[trackdir]);
1189 if (tile == INVALID_TILE) return false;
1190
1191 /* Check for track bits on the new tile */
1192 TrackdirBits trackdirbits = TrackStatusToTrackdirBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0));
1193
1194 if (TracksOverlap(TrackdirBitsToTrackBits(trackdirbits))) return false;
1195 trackdirbits &= TrackdirReachesTrackdirs(trackdir);
1196
1197 /* No track bits, must stop */
1198 if (trackdirbits == TRACKDIR_BIT_NONE) return false;
1199
1200 /* Get the first track dir */
1201 trackdir = RemoveFirstTrackdir(&trackdirbits);
1202
1203 /* Any left? It's a junction so we stop */
1204 if (trackdirbits != TRACKDIR_BIT_NONE) return false;
1205
1206 switch (GetTileType(tile)) {
1207 case MP_RAILWAY:
1208 if (IsRailDepot(tile)) return false;
1209 if (!remove && HasSignalOnTrack(tile, TrackdirToTrack(trackdir))) return false;
1210 signal_ctr++;
1211 if (IsDiagonalTrackdir(trackdir)) {
1212 signal_ctr++;
1213 /* Ensure signal_ctr even so X and Y pieces get signals */
1214 ClrBit(signal_ctr, 0);
1215 }
1216 return true;
1217
1218 case MP_ROAD:
1219 if (!IsLevelCrossing(tile)) return false;
1220 signal_ctr += 2;
1221 return true;
1222
1223 case MP_TUNNELBRIDGE: {
1224 TileIndex orig_tile = tile; // backup old value
1225
1226 if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) return false;
1227 if (GetTunnelBridgeDirection(tile) != TrackdirToExitdir(trackdir)) return false;
1228
1229 /* Skip to end of tunnel or bridge
1230 * note that tile is a parameter by reference, so it must be updated */
1231 tile = GetOtherTunnelBridgeEnd(tile);
1232
1233 signal_ctr += (GetTunnelBridgeLength(orig_tile, tile) + 2) * 2;
1234 return true;
1235 }
1236
1237 default: return false;
1238 }
1239 }
1240
1258 static CommandCost CmdSignalTrackHelper(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
1259 {
1260 CommandCost total_cost(EXPENSES_CONSTRUCTION);
1261 TileIndex start_tile = tile;
1262
1263 Track track = Extract<Track, 0, 3>(p2);
1264 bool mode = HasBit(p2, 3);
1265 bool semaphores = HasBit(p2, 4);
1266 bool remove = HasBit(p2, 5);
1267 bool autofill = HasBit(p2, 6);
1268 bool minimise_gaps = HasBit(p2, 10);
1269 byte signal_density = GB(p2, 24, 8);
1270
1271 if (p1 >= MapSize() || !ValParamTrackOrientation(track)) return CMD_ERROR;
1272 TileIndex end_tile = p1;
1273 if (signal_density == 0 || signal_density > 20) return CMD_ERROR;
1274
1275 if (!IsPlainRailTile(tile)) return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
1276
1277 /* for vertical/horizontal tracks, double the given signals density
1278 * since the original amount will be too dense (shorter tracks) */
1279 signal_density *= 2;
1280
1281 Trackdir trackdir = TrackToTrackdir(track);
1282 CommandCost ret = ValidateAutoDrag(&trackdir, tile, end_tile);
1283 if (ret.Failed()) return ret;
1284
1285 track = TrackdirToTrack(trackdir); // trackdir might have changed, keep track in sync
1286 Trackdir start_trackdir = trackdir;
1287
1288 /* Must start on a valid track to be able to avoid loops */
1289 if (!HasTrack(tile, track)) return CMD_ERROR;
1290
1291 SignalType sigtype = (SignalType)GB(p2, 7, 3);
1292 if (sigtype > SIGTYPE_LAST) return CMD_ERROR;
1293
1294 byte signals;
1295 /* copy the signal-style of the first rail-piece if existing */
1296 if (HasSignalOnTrack(tile, track)) {
1297 signals = GetPresentSignals(tile) & SignalOnTrack(track);
1298 assert(signals != 0);
1299
1300 /* copy signal/semaphores style (independent of CTRL) */
1301 semaphores = GetSignalVariant(tile, track) != SIG_ELECTRIC;
1302
1303 sigtype = GetSignalType(tile, track);
1304 /* Don't but copy entry or exit-signal type */
1305 if (sigtype == SIGTYPE_ENTRY || sigtype == SIGTYPE_EXIT) sigtype = SIGTYPE_NORMAL;
1306 } else { // no signals exist, drag a two-way signal stretch
1307 signals = IsPbsSignal(sigtype) ? SignalAlongTrackdir(trackdir) : SignalOnTrack(track);
1308 }
1309
1310 byte signal_dir = 0;
1311 if (signals & SignalAlongTrackdir(trackdir)) SetBit(signal_dir, 0);
1312 if (signals & SignalAgainstTrackdir(trackdir)) SetBit(signal_dir, 1);
1313
1314 /* signal_ctr - amount of tiles already processed
1315 * last_used_ctr - amount of tiles before previously placed signal
1316 * signals_density - setting to put signal on every Nth tile (double space on |, -- tracks)
1317 * last_suitable_ctr - amount of tiles before last possible signal place
1318 * last_suitable_tile - last tile where it is possible to place a signal
1319 * last_suitable_trackdir - trackdir of the last tile
1320 **********
1321 * trackdir - trackdir to build with autorail
1322 * semaphores - semaphores or signals
1323 * signals - is there a signal/semaphore on the first tile, copy its style (two-way/single-way)
1324 * and convert all others to semaphore/signal
1325 * remove - 1 remove signals, 0 build signals */
1326 int signal_ctr = 0;
1327 int last_used_ctr = INT_MIN; // initially INT_MIN to force building/removing at the first tile
1328 int last_suitable_ctr = 0;
1329 TileIndex last_suitable_tile = INVALID_TILE;
1330 Trackdir last_suitable_trackdir = INVALID_TRACKDIR;
1331 CommandCost last_error = CMD_ERROR;
1332 bool had_success = false;
1333 for (;;) {
1334 /* only build/remove signals with the specified density */
1335 if (remove || minimise_gaps || signal_ctr % signal_density == 0) {
1336 uint32 p1 = GB(TrackdirToTrack(trackdir), 0, 3);
1337 SB(p1, 3, 1, mode);
1338 SB(p1, 4, 1, semaphores);
1339 SB(p1, 5, 3, sigtype);
1340 if (!remove && signal_ctr == 0) SetBit(p1, 17);
1341
1342 /* Pick the correct orientation for the track direction */
1343 signals = 0;
1344 if (HasBit(signal_dir, 0)) signals |= SignalAlongTrackdir(trackdir);
1345 if (HasBit(signal_dir, 1)) signals |= SignalAgainstTrackdir(trackdir);
1346
1347 /* Test tiles in between for suitability as well if minimising gaps. */
1348 bool test_only = !remove && minimise_gaps && signal_ctr < (last_used_ctr + signal_density);
1349 CommandCost ret = DoCommand(tile, p1, signals, test_only ? flags & ~DC_EXEC : flags, remove ? CMD_REMOVE_SIGNALS : CMD_BUILD_SIGNALS);
1350
1351 if (ret.Succeeded()) {
1352 /* Remember last track piece where we can place a signal. */
1353 last_suitable_ctr = signal_ctr;
1354 last_suitable_tile = tile;
1355 last_suitable_trackdir = trackdir;
1356 } else if (!test_only && last_suitable_tile != INVALID_TILE) {
1357 /* If a signal can't be placed, place it at the last possible position. */
1358 SB(p1, 0, 3, TrackdirToTrack(last_suitable_trackdir));
1359 ClrBit(p1, 17);
1360
1361 /* Pick the correct orientation for the track direction. */
1362 signals = 0;
1363 if (HasBit(signal_dir, 0)) signals |= SignalAlongTrackdir(last_suitable_trackdir);
1364 if (HasBit(signal_dir, 1)) signals |= SignalAgainstTrackdir(last_suitable_trackdir);
1365
1366 ret = DoCommand(last_suitable_tile, p1, signals, flags, remove ? CMD_REMOVE_SIGNALS : CMD_BUILD_SIGNALS);
1367 }
1368
1369 /* Collect cost. */
1370 if (!test_only) {
1371 /* Be user-friendly and try placing signals as much as possible */
1372 if (ret.Succeeded()) {
1373 had_success = true;
1374 total_cost.AddCost(ret);
1375 last_used_ctr = last_suitable_ctr;
1376 last_suitable_tile = INVALID_TILE;
1377 } else {
1378 /* The "No railway" error is the least important one. */
1379 if (ret.GetErrorMessage() != STR_ERROR_THERE_IS_NO_RAILROAD_TRACK ||
1380 last_error.GetErrorMessage() == INVALID_STRING_ID) {
1381 last_error = ret;
1382 }
1383 }
1384 }
1385 }
1386
1387 if (autofill) {
1388 if (!CheckSignalAutoFill(tile, trackdir, signal_ctr, remove)) break;
1389
1390 /* Prevent possible loops */
1391 if (tile == start_tile && trackdir == start_trackdir) break;
1392 } else {
1393 if (tile == end_tile) break;
1394
1395 tile += ToTileIndexDiff(_trackdelta[trackdir]);
1396 signal_ctr++;
1397
1398 /* toggle railbit for the non-diagonal tracks (|, -- tracks) */
1399 if (IsDiagonalTrackdir(trackdir)) {
1400 signal_ctr++;
1401 } else {
1402 ToggleBit(trackdir, 0);
1403 }
1404 }
1405 }
1406
1407 return had_success ? total_cost : last_error;
1408 }
1409
1428 CommandCost CmdBuildSignalTrack(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
1429 {
1430 return CmdSignalTrackHelper(tile, flags, p1, p2, text);
1431 }
1432
1445 CommandCost CmdRemoveSingleSignal(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
1446 {
1447 Track track = Extract<Track, 0, 3>(p1);
1448
1449 if (!ValParamTrackOrientation(track) || !IsPlainRailTile(tile) || !HasTrack(tile, track)) {
1450 return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);
1451 }
1452 if (!HasSignalOnTrack(tile, track)) {
1453 return_cmd_error(STR_ERROR_THERE_ARE_NO_SIGNALS);
1454 }
1455
1456 /* Only water can remove signals from anyone */
1457 if (_current_company != OWNER_WATER) {
1458 CommandCost ret = CheckTileOwnership(tile);
1459 if (ret.Failed()) return ret;
1460 }
1461
1462 /* Do it? */
1463 if (flags & DC_EXEC) {
1464 Train *v = NULL;
1465 if (HasReservedTracks(tile, TrackToTrackBits(track))) {
1466 v = GetTrainForReservation(tile, track);
1467 } else if (IsPbsSignal(GetSignalType(tile, track))) {
1468 /* PBS signal, might be the end of a path reservation. */
1469 Trackdir td = TrackToTrackdir(track);
1470 for (int i = 0; v == NULL && i < 2; i++, td = ReverseTrackdir(td)) {
1471 /* Only test the active signal side. */
1472 if (!HasSignalOnTrackdir(tile, ReverseTrackdir(td))) continue;
1473 TileIndex next = TileAddByDiagDir(tile, TrackdirToExitdir(td));
1474 TrackBits tracks = TrackdirBitsToTrackBits(TrackdirReachesTrackdirs(td));
1475 if (HasReservedTracks(next, tracks)) {
1476 v = GetTrainForReservation(next, TrackBitsToTrack(GetReservedTrackbits(next) & tracks));
1477 }
1478 }
1479 }
1480 Company::Get(GetTileOwner(tile))->infrastructure.signal -= CountBits(GetPresentSignals(tile));
1481 SetPresentSignals(tile, GetPresentSignals(tile) & ~SignalOnTrack(track));
1482 Company::Get(GetTileOwner(tile))->infrastructure.signal += CountBits(GetPresentSignals(tile));
1483 DirtyCompanyInfrastructureWindows(GetTileOwner(tile));
1484
1485 /* removed last signal from tile? */
1486 if (GetPresentSignals(tile) == 0) {
1487 SetSignalStates(tile, 0);
1488 SetHasSignals(tile, false);
1489 SetSignalVariant(tile, INVALID_TRACK, SIG_ELECTRIC); // remove any possible semaphores
1490 }
1491
1492 AddTrackToSignalBuffer(tile, track, GetTileOwner(tile));
1493 YapfNotifyTrackLayoutChange(tile, track);
1494 if (v != NULL) TryPathReserve(v, false);
1495
1496 MarkTileDirtyByTile(tile);
1497 }
1498
1499 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_SIGNALS]);
1500 }
1501
1520 CommandCost CmdRemoveSignalTrack(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
1521 {
1522 return CmdSignalTrackHelper(tile, flags, p1, SetBit(p2, 5), text); // bit 5 is remove bit
1523 }
1524
1526 static Vehicle *UpdateTrainPowerProc(Vehicle *v, void *data)
1527 {
1528 if (v->type != VEH_TRAIN) return NULL;
1529
1530 TrainList *affected_trains = static_cast<TrainList*>(data);
1531 affected_trains->Include(Train::From(v)->First());
1532
1533 return NULL;
1534 }
1535
1548 CommandCost CmdConvertRail(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
1549 {
1550 RailType totype = Extract<RailType, 0, 4>(p2);
1551 TileIndex area_start = p1;
1552 TileIndex area_end = tile;
1553 bool diagonal = HasBit(p2, 4);
1554
1555 if (!ValParamRailtype(totype)) return CMD_ERROR;
1556 if (area_start >= MapSize()) return CMD_ERROR;
1557
1558 TrainList affected_trains;
1559
1560 CommandCost cost(EXPENSES_CONSTRUCTION);
1561 CommandCost error = CommandCost(STR_ERROR_NO_SUITABLE_RAILROAD_TRACK); // by default, there is no track to convert.
1562
1563 TileIterator *iter = diagonal ? (TileIterator *)new DiagonalTileIterator(area_start, area_end) : new OrthogonalTileIterator(area_start, area_end);
1564 for (; (tile = *iter) != INVALID_TILE; ++(*iter)) {
1565 TileType tt = GetTileType(tile);
1566
1567 /* Check if there is any track on tile */
1568 switch (tt) {
1569 case MP_RAILWAY:
1570 break;
1571 case MP_STATION:
1572 if (!HasStationRail(tile)) continue;
1573 break;
1574 case MP_ROAD:
1575 if (!IsLevelCrossing(tile)) continue;
1576 if (RailNoLevelCrossings(totype)) {
1577 error.MakeError(STR_ERROR_CROSSING_DISALLOWED);
1578 continue;
1579 }
1580 break;
1581 case MP_TUNNELBRIDGE:
1582 if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) continue;
1583 break;
1584 default: continue;
1585 }
1586
1587 /* Original railtype we are converting from */
1588 RailType type = GetRailType(tile);
1589
1590 /* Converting to the same type or converting 'hidden' elrail -> rail */
1591 if (type == totype || (_settings_game.vehicle.disable_elrails && totype == RAILTYPE_RAIL && type == RAILTYPE_ELECTRIC)) continue;
1592
1593 /* Trying to convert other's rail */
1594 CommandCost ret = CheckTileOwnership(tile);
1595 if (ret.Failed()) {
1596 error = ret;
1597 continue;
1598 }
1599
1600 SmallVector<Train *, 2> vehicles_affected;
1601
1602 /* Vehicle on the tile when not converting Rail <-> ElRail
1603 * Tunnels and bridges have special check later */
1604 if (tt != MP_TUNNELBRIDGE) {
1605 if (!IsCompatibleRail(type, totype)) {
1606 CommandCost ret = IsPlainRailTile(tile) ? EnsureNoTrainOnTrackBits(tile, GetTrackBits(tile)) : EnsureNoVehicleOnGround(tile);
1607 if (ret.Failed()) {
1608 error = ret;
1609 continue;
1610 }
1611 }
1612 if (flags & DC_EXEC) { // we can safely convert, too
1613 TrackBits reserved = GetReservedTrackbits(tile);
1614 Track track;
1615 while ((track = RemoveFirstTrack(&reserved)) != INVALID_TRACK) {
1616 Train *v = GetTrainForReservation(tile, track);
1617 if (v != NULL && !HasPowerOnRail(v->railtype, totype)) {
1618 /* No power on new rail type, reroute. */
1619 FreeTrainTrackReservation(v);
1620 *vehicles_affected.Append() = v;
1621 }
1622 }
1623
1624 /* Update the company infrastructure counters. */
1625 if (!IsRailStationTile(tile) || !IsStationTileBlocked(tile)) {
1626 Company *c = Company::Get(GetTileOwner(tile));
1627 uint num_pieces = IsLevelCrossingTile(tile) ? LEVELCROSSING_TRACKBIT_FACTOR : 1;
1628 if (IsPlainRailTile(tile)) {
1629 TrackBits bits = GetTrackBits(tile);
1630 num_pieces = CountBits(bits);
1631 if (TracksOverlap(bits)) num_pieces *= num_pieces;
1632 }
1633 c->infrastructure.rail[type] -= num_pieces;
1634 c->infrastructure.rail[totype] += num_pieces;
1635 DirtyCompanyInfrastructureWindows(c->index);
1636 }
1637
1638 SetRailType(tile, totype);
1639 MarkTileDirtyByTile(tile);
1640 /* update power of train on this tile */
1641 FindVehicleOnPos(tile, &affected_trains, &UpdateTrainPowerProc);
1642 }
1643 }
1644
1645 switch (tt) {
1646 case MP_RAILWAY:
1647 switch (GetRailTileType(tile)) {
1648 case RAIL_TILE_DEPOT:
1649 if (flags & DC_EXEC) {
1650 /* notify YAPF about the track layout change */
1651 YapfNotifyTrackLayoutChange(tile, GetRailDepotTrack(tile));
1652
1653 /* Update build vehicle window related to this depot */
1654 InvalidateWindowData(WC_VEHICLE_DEPOT, tile);
1655 InvalidateWindowData(WC_BUILD_VEHICLE, tile);
1656 }
1657 cost.AddCost(RailConvertCost(type, totype));
1658 break;
1659
1660 default: // RAIL_TILE_NORMAL, RAIL_TILE_SIGNALS
1661 if (flags & DC_EXEC) {
1662 /* notify YAPF about the track layout change */
1663 TrackBits tracks = GetTrackBits(tile);
1664 while (tracks != TRACK_BIT_NONE) {
1665 YapfNotifyTrackLayoutChange(tile, RemoveFirstTrack(&tracks));
1666 }
1667 }
1668 cost.AddCost(RailConvertCost(type, totype) * CountBits(GetTrackBits(tile)));
1669 break;
1670 }
1671 break;
1672
1673 case MP_TUNNELBRIDGE: {
1674 TileIndex endtile = GetOtherTunnelBridgeEnd(tile);
1675
1676 /* If both ends of tunnel/bridge are in the range, do not try to convert twice -
1677 * it would cause assert because of different test and exec runs */
1678 if (endtile < tile) {
1679 if (diagonal) {
1680 if (DiagonalTileArea(area_start, area_end).Contains(endtile)) continue;
1681 } else {
1682 if (OrthogonalTileArea(area_start, area_end).Contains(endtile)) continue;
1683 }
1684 }
1685
1686 /* When not converting rail <-> el. rail, any vehicle cannot be in tunnel/bridge */
1687 if (!IsCompatibleRail(GetRailType(tile), totype)) {
1688 CommandCost ret = TunnelBridgeIsFree(tile, endtile);
1689 if (ret.Failed()) {
1690 error = ret;
1691 continue;
1692 }
1693 }
1694
1695 if (flags & DC_EXEC) {
1696 Track track = DiagDirToDiagTrack(GetTunnelBridgeDirection(tile));
1697 if (HasTunnelBridgeReservation(tile)) {
1698 Train *v = GetTrainForReservation(tile, track);
1699 if (v != NULL && !HasPowerOnRail(v->railtype, totype)) {
1700 /* No power on new rail type, reroute. */
1701 FreeTrainTrackReservation(v);
1702 *vehicles_affected.Append() = v;
1703 }
1704 }
1705
1706 /* Update the company infrastructure counters. */
1707 uint num_pieces = (GetTunnelBridgeLength(tile, endtile) + 2) * TUNNELBRIDGE_TRACKBIT_FACTOR;
1708 Company *c = Company::Get(GetTileOwner(tile));
1709 c->infrastructure.rail[GetRailType(tile)] -= num_pieces;
1710 c->infrastructure.rail[totype] += num_pieces;
1711 DirtyCompanyInfrastructureWindows(c->index);
1712
1713 SetRailType(tile, totype);
1714 SetRailType(endtile, totype);
1715
1716 FindVehicleOnPos(tile, &affected_trains, &UpdateTrainPowerProc);
1717 FindVehicleOnPos(endtile, &affected_trains, &UpdateTrainPowerProc);
1718
1719 YapfNotifyTrackLayoutChange(tile, track);
1720 YapfNotifyTrackLayoutChange(endtile, track);
1721
1722 if (IsBridge(tile)) {
1723 MarkBridgeDirty(tile);
1724 } else {
1725 MarkTileDirtyByTile(tile);
1726 MarkTileDirtyByTile(endtile);
1727 }
1728 }
1729
1730 cost.AddCost((GetTunnelBridgeLength(tile, endtile) + 2) * RailConvertCost(type, totype));
1731 break;
1732 }
1733
1734 default: // MP_STATION, MP_ROAD
1735 if (flags & DC_EXEC) {
1736 Track track = ((tt == MP_STATION) ? GetRailStationTrack(tile) : GetCrossingRailTrack(tile));
1737 YapfNotifyTrackLayoutChange(tile, track);
1738 }
1739
1740 cost.AddCost(RailConvertCost(type, totype));
1741 break;
1742 }
1743
1744 for (uint i = 0; i < vehicles_affected.Length(); ++i) {
1745 TryPathReserve(vehicles_affected[i], true);
1746 }
1747 }
1748
1749 if (flags & DC_EXEC) {
1750 /* Railtype changed, update trains as when entering different track */
1751 for (Train **v = affected_trains.Begin(); v != affected_trains.End(); v++) {
1752 (*v)->ConsistChanged(CCF_TRACK);
1753 }
1754 }
1755
1756 delete iter;
1757 return (cost.GetCost() == 0) ? error : cost;
1758 }
1759
1760 static CommandCost RemoveTrainDepot(TileIndex tile, DoCommandFlag flags)
1761 {
1762 if (_current_company != OWNER_WATER) {
1763 CommandCost ret = CheckTileOwnership(tile);
1764 if (ret.Failed()) return ret;
1765 }
1766
1767 CommandCost ret = EnsureNoVehicleOnGround(tile);
1768 if (ret.Failed()) return ret;
1769
1770 if (flags & DC_EXEC) {
1771 /* read variables before the depot is removed */
1772 DiagDirection dir = GetRailDepotDirection(tile);
1773 Owner owner = GetTileOwner(tile);
1774 Train *v = NULL;
1775
1776 if (HasDepotReservation(tile)) {
1777 v = GetTrainForReservation(tile, DiagDirToDiagTrack(dir));
1778 if (v != NULL) FreeTrainTrackReservation(v);
1779 }
1780
1781 Company::Get(owner)->infrastructure.rail[GetRailType(tile)]--;
1782 DirtyCompanyInfrastructureWindows(owner);
1783
1784 delete Depot::GetByTile(tile);
1785 DoClearSquare(tile);
1786 AddSideToSignalBuffer(tile, dir, owner);
1787 YapfNotifyTrackLayoutChange(tile, DiagDirToDiagTrack(dir));
1788 if (v != NULL) TryPathReserve(v, true);
1789 }
1790
1791 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_DEPOT_TRAIN]);
1792 }
1793
1794 static CommandCost ClearTile_Track(TileIndex tile, DoCommandFlag flags)
1795 {
1796 CommandCost cost(EXPENSES_CONSTRUCTION);
1797
1798 if (flags & DC_AUTO) {
1799 if (!IsTileOwner(tile, _current_company)) {
1800 return_cmd_error(STR_ERROR_AREA_IS_OWNED_BY_ANOTHER);
1801 }
1802
1803 if (IsPlainRail(tile)) {
1804 return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
1805 } else {
1806 return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
1807 }
1808 }
1809
1810 switch (GetRailTileType(tile)) {
1811 case RAIL_TILE_SIGNALS:
1812 case RAIL_TILE_NORMAL: {
1813 Slope tileh = GetTileSlope(tile);
1814 /* Is there flat water on the lower halftile that gets cleared expensively? */
1815 bool water_ground = (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh));
1816
1817 TrackBits tracks = GetTrackBits(tile);
1818 while (tracks != TRACK_BIT_NONE) {
1819 Track track = RemoveFirstTrack(&tracks);
1820 CommandCost ret = DoCommand(tile, 0, track, flags, CMD_REMOVE_SINGLE_RAIL);
1821 if (ret.Failed()) return ret;
1822 cost.AddCost(ret);
1823 }
1824
1825 /* When bankrupting, don't make water dirty, there could be a ship on lower halftile.
1826 * Same holds for non-companies clearing the tile, e.g. disasters. */
1827 if (water_ground && !(flags & DC_BANKRUPT) && Company::IsValidID(_current_company)) {
1828 CommandCost ret = EnsureNoVehicleOnGround(tile);
1829 if (ret.Failed()) return ret;
1830
1831 /* The track was removed, and left a coast tile. Now also clear the water. */
1832 if (flags & DC_EXEC) DoClearSquare(tile);
1833 cost.AddCost(_price[PR_CLEAR_WATER]);
1834 }
1835
1836 return cost;
1837 }
1838
1839 case RAIL_TILE_DEPOT:
1840 return RemoveTrainDepot(tile, flags);
1841
1842 default:
1843 return CMD_ERROR;
1844 }
1845 }
1846
1851 static uint GetSaveSlopeZ(uint x, uint y, Track track)
1852 {
1853 switch (track) {
1854 case TRACK_UPPER: x &= ~0xF; y &= ~0xF; break;
1855 case TRACK_LOWER: x |= 0xF; y |= 0xF; break;
1856 case TRACK_LEFT: x |= 0xF; y &= ~0xF; break;
1857 case TRACK_RIGHT: x &= ~0xF; y |= 0xF; break;
1858 default: break;
1859 }
1860 return GetSlopePixelZ(x, y);
1861 }
1862
1863 static void DrawSingleSignal(TileIndex tile, const RailtypeInfo *rti, Track track, SignalState condition, SignalOffsets image, uint pos)
1864 {
1865 bool side;
1866 switch (_settings_game.construction.train_signal_side) {
1867 case 0: side = false; break; // left
1868 case 2: side = true; break; // right
1869 default: side = _settings_game.vehicle.road_side != 0; break; // driving side
1870 }
1871 static const Point SignalPositions[2][12] = {
1872 { // Signals on the left side
1873 /* LEFT LEFT RIGHT RIGHT UPPER UPPER */
1874 { 8, 5}, {14, 1}, { 1, 14}, { 9, 11}, { 1, 0}, { 3, 10},
1875 /* LOWER LOWER X X Y Y */
1876 {11, 4}, {14, 14}, {11, 3}, { 4, 13}, { 3, 4}, {11, 13}
1877 }, { // Signals on the right side
1878 /* LEFT LEFT RIGHT RIGHT UPPER UPPER */
1879 {14, 1}, {12, 10}, { 4, 6}, { 1, 14}, {10, 4}, { 0, 1},
1880 /* LOWER LOWER X X Y Y */
1881 {14, 14}, { 5, 12}, {11, 13}, { 4, 3}, {13, 4}, { 3, 11}
1882 }
1883 };
1884
1885 uint x = TileX(tile) * TILE_SIZE + SignalPositions[side][pos].x;
1886 uint y = TileY(tile) * TILE_SIZE + SignalPositions[side][pos].y;
1887
1888 SignalType type = GetSignalType(tile, track);
1889 SignalVariant variant = GetSignalVariant(tile, track);
1890
1891 SpriteID sprite = GetCustomSignalSprite(rti, tile, type, variant, condition);
1892 if (sprite != 0) {
1893 sprite += image;
1894 } else {
1895 /* Normal electric signals are stored in a different sprite block than all other signals. */
1896 sprite = (type == SIGTYPE_NORMAL && variant == SIG_ELECTRIC) ? SPR_ORIGINAL_SIGNALS_BASE : SPR_SIGNALS_BASE - 16;
1897 sprite += type * 16 + variant * 64 + image * 2 + condition + (type > SIGTYPE_LAST_NOPBS ? 64 : 0);
1898 }
1899
1900 AddSortableSpriteToDraw(sprite, PAL_NONE, x, y, 1, 1, BB_HEIGHT_UNDER_BRIDGE, GetSaveSlopeZ(x, y, track));
1901 }
1902
1903 static uint32 _drawtile_track_palette;
1904
1905
1906
1908 struct FenceOffset {
1909 Corner height_ref;
1910 int x_offs;
1911 int y_offs;
1912 int x_size;
1913 int y_size;
1914 };
1915
1917 static FenceOffset _fence_offsets[] = {
1918 { CORNER_INVALID, 0, 1, 16, 1 }, // RFO_FLAT_X_NW
1919 { CORNER_INVALID, 1, 0, 1, 16 }, // RFO_FLAT_Y_NE
1920 { CORNER_W, 8, 8, 1, 1 }, // RFO_FLAT_LEFT
1921 { CORNER_N, 8, 8, 1, 1 }, // RFO_FLAT_UPPER
1922 { CORNER_INVALID, 0, 1, 16, 1 }, // RFO_SLOPE_SW_NW
1923 { CORNER_INVALID, 1, 0, 1, 16 }, // RFO_SLOPE_SE_NE
1924 { CORNER_INVALID, 0, 1, 16, 1 }, // RFO_SLOPE_NE_NW
1925 { CORNER_INVALID, 1, 0, 1, 16 }, // RFO_SLOPE_NW_NE
1926 { CORNER_INVALID, 0, 15, 16, 1 }, // RFO_FLAT_X_SE
1927 { CORNER_INVALID, 15, 0, 1, 16 }, // RFO_FLAT_Y_SW
1928 { CORNER_E, 8, 8, 1, 1 }, // RFO_FLAT_RIGHT
1929 { CORNER_S, 8, 8, 1, 1 }, // RFO_FLAT_LOWER
1930 { CORNER_INVALID, 0, 15, 16, 1 }, // RFO_SLOPE_SW_SE
1931 { CORNER_INVALID, 15, 0, 1, 16 }, // RFO_SLOPE_SE_SW
1932 { CORNER_INVALID, 0, 15, 16, 1 }, // RFO_SLOPE_NE_SE
1933 { CORNER_INVALID, 15, 0, 1, 16 }, // RFO_SLOPE_NW_SW
1934 };
1935
1943 static void DrawTrackFence(const TileInfo *ti, SpriteID base_image, uint num_sprites, RailFenceOffset rfo)
1944 {
1945 int z = ti->z;
1946 if (_fence_offsets[rfo].height_ref != CORNER_INVALID) {
1947 z += GetSlopePixelZInCorner(RemoveHalftileSlope(ti->tileh), _fence_offsets[rfo].height_ref);
1948 }
1949 AddSortableSpriteToDraw(base_image + (rfo % num_sprites), _drawtile_track_palette,
1950 ti->x + _fence_offsets[rfo].x_offs,
1951 ti->y + _fence_offsets[rfo].y_offs,
1952 _fence_offsets[rfo].x_size,
1953 _fence_offsets[rfo].y_size,
1954 4, z);
1955 }
1956
1960 static void DrawTrackFence_NW(const TileInfo *ti, SpriteID base_image, uint num_sprites)
1961 {
1962 RailFenceOffset rfo = RFO_FLAT_X_NW;
1963 if (ti->tileh & SLOPE_NW) rfo = (ti->tileh & SLOPE_W) ? RFO_SLOPE_SW_NW : RFO_SLOPE_NE_NW;
1964 DrawTrackFence(ti, base_image, num_sprites, rfo);
1965 }
1966
1970 static void DrawTrackFence_SE(const TileInfo *ti, SpriteID base_image, uint num_sprites)
1971 {
1972 RailFenceOffset rfo = RFO_FLAT_X_SE;
1973 if (ti->tileh & SLOPE_SE) rfo = (ti->tileh & SLOPE_S) ? RFO_SLOPE_SW_SE : RFO_SLOPE_NE_SE;
1974 DrawTrackFence(ti, base_image, num_sprites, rfo);
1975 }
1976
1980 static void DrawTrackFence_NE(const TileInfo *ti, SpriteID base_image, uint num_sprites)
1981 {
1982 RailFenceOffset rfo = RFO_FLAT_Y_NE;
1983 if (ti->tileh & SLOPE_NE) rfo = (ti->tileh & SLOPE_E) ? RFO_SLOPE_SE_NE : RFO_SLOPE_NW_NE;
1984 DrawTrackFence(ti, base_image, num_sprites, rfo);
1985 }
1986
1990 static void DrawTrackFence_SW(const TileInfo *ti, SpriteID base_image, uint num_sprites)
1991 {
1992 RailFenceOffset rfo = RFO_FLAT_Y_SW;
1993 if (ti->tileh & SLOPE_SW) rfo = (ti->tileh & SLOPE_S) ? RFO_SLOPE_SE_SW : RFO_SLOPE_NW_SW;
1994 DrawTrackFence(ti, base_image, num_sprites, rfo);
1995 }
1996
2002 static void DrawTrackDetails(const TileInfo *ti, const RailtypeInfo *rti)
2003 {
2004 /* Base sprite for track fences.
2005 * Note: Halftile slopes only have fences on the upper part. */
2006 uint num_sprites = 0;
2007 SpriteID base_image = GetCustomRailSprite(rti, ti->tile, RTSG_FENCES, IsHalftileSlope(ti->tileh) ? TCX_UPPER_HALFTILE : TCX_NORMAL, &num_sprites);
2008 if (base_image == 0) {
2009 base_image = SPR_TRACK_FENCE_FLAT_X;
2010 num_sprites = 8;
2011 }
2012
2013 assert(num_sprites > 0);
2014
2015 switch (GetRailGroundType(ti->tile)) {
2016 case RAIL_GROUND_FENCE_NW: DrawTrackFence_NW(ti, base_image, num_sprites); break;
2017 case RAIL_GROUND_FENCE_SE: DrawTrackFence_SE(ti, base_image, num_sprites); break;
2018 case RAIL_GROUND_FENCE_SENW: DrawTrackFence_NW(ti, base_image, num_sprites);
2019 DrawTrackFence_SE(ti, base_image, num_sprites); break;
2020 case RAIL_GROUND_FENCE_NE: DrawTrackFence_NE(ti, base_image, num_sprites); break;
2021 case RAIL_GROUND_FENCE_SW: DrawTrackFence_SW(ti, base_image, num_sprites); break;
2022 case RAIL_GROUND_FENCE_NESW: DrawTrackFence_NE(ti, base_image, num_sprites);
2023 DrawTrackFence_SW(ti, base_image, num_sprites); break;
2024 case RAIL_GROUND_FENCE_VERT1: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LEFT); break;
2025 case RAIL_GROUND_FENCE_VERT2: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_RIGHT); break;
2026 case RAIL_GROUND_FENCE_HORIZ1: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_UPPER); break;
2027 case RAIL_GROUND_FENCE_HORIZ2: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LOWER); break;
2028 case RAIL_GROUND_WATER: {
2029 Corner track_corner;
2030 if (IsHalftileSlope(ti->tileh)) {
2031 /* Steep slope or one-corner-raised slope with halftile foundation */
2032 track_corner = GetHalftileSlopeCorner(ti->tileh);
2033 } else {
2034 /* Three-corner-raised slope */
2035 track_corner = OppositeCorner(GetHighestSlopeCorner(ComplementSlope(ti->tileh)));
2036 }
2037 switch (track_corner) {
2038 case CORNER_W: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LEFT); break;
2039 case CORNER_S: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_LOWER); break;
2040 case CORNER_E: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_RIGHT); break;
2041 case CORNER_N: DrawTrackFence(ti, base_image, num_sprites, RFO_FLAT_UPPER); break;
2042 default: NOT_REACHED();
2043 }
2044 break;
2045 }
2046 default: break;
2047 }
2048 }
2049
2050 /* SubSprite for drawing the track halftile of 'three-corners-raised'-sloped rail sprites. */
2051 static const int INF = 1000; // big number compared to tilesprite size
2052 static const SubSprite _halftile_sub_sprite[4] = {
2053 { -INF , -INF , 32 - 33, INF }, // CORNER_W, clip 33 pixels from right
2054 { -INF , 0 + 7, INF , INF }, // CORNER_S, clip 7 pixels from top
2055 { -31 + 33, -INF , INF , INF }, // CORNER_E, clip 33 pixels from left
2056 { -INF , -INF , INF , 30 - 23 } // CORNER_N, clip 23 pixels from bottom
2057 };
2058
2059 static inline void DrawTrackSprite(SpriteID sprite, PaletteID pal, const TileInfo *ti, Slope s)
2060 {
2061 DrawGroundSprite(sprite, pal, NULL, 0, (ti->tileh & s) ? -8 : 0);
2062 }
2063
2064 static void DrawTrackBitsOverlay(TileInfo *ti, TrackBits track, const RailtypeInfo *rti)
2065 {
2066 RailGroundType rgt = GetRailGroundType(ti->tile);
2067 Foundation f = GetRailFoundation(ti->tileh, track);
2068 Corner halftile_corner = CORNER_INVALID;
2069
2070 if (IsNonContinuousFoundation(f)) {
2071 /* Save halftile corner */
2072 halftile_corner = (f == FOUNDATION_STEEP_BOTH ? GetHighestSlopeCorner(ti->tileh) : GetHalftileFoundationCorner(f));
2073 /* Draw lower part first */
2074 track &= ~CornerToTrackBits(halftile_corner);
2075 f = (f == FOUNDATION_STEEP_BOTH ? FOUNDATION_STEEP_LOWER : FOUNDATION_NONE);
2076 }
2077
2078 DrawFoundation(ti, f);
2079 /* DrawFoundation modifies ti */
2080
2081 /* Draw ground */
2082 if (rgt == RAIL_GROUND_WATER) {
2083 if (track != TRACK_BIT_NONE || IsSteepSlope(ti->tileh)) {
2084 /* three-corner-raised slope or steep slope with track on upper part */
2085 DrawShoreTile(ti->tileh);
2086 } else {
2087 /* single-corner-raised slope with track on upper part */
2088 DrawGroundSprite(SPR_FLAT_WATER_TILE, PAL_NONE);
2089 }
2090 } else {
2091 SpriteID image;
2092
2093 switch (rgt) {
2094 case RAIL_GROUND_BARREN: image = SPR_FLAT_BARE_LAND; break;
2095 case RAIL_GROUND_ICE_DESERT: image = SPR_FLAT_SNOW_DESERT_TILE; break;
2096 default: image = SPR_FLAT_GRASS_TILE; break;
2097 }
2098
2099 image += SlopeToSpriteOffset(ti->tileh);
2100
2101 DrawGroundSprite(image, PAL_NONE);
2102 }
2103
2104 SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY);
2105 SpriteID ground = GetCustomRailSprite(rti, ti->tile, RTSG_GROUND);
2106 TrackBits pbs = _settings_client.gui.show_track_reservation ? GetRailReservationTrackBits(ti->tile) : TRACK_BIT_NONE;
2107
2108 if (track == TRACK_BIT_NONE) {
2109 /* Half-tile foundation, no track here? */
2110 } else if (ti->tileh == SLOPE_NW && track == TRACK_BIT_Y) {
2111 DrawGroundSprite(ground + RTO_SLOPE_NW, PAL_NONE);
2112 if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + RTO_SLOPE_NW, PALETTE_CRASH);
2113 } else if (ti->tileh == SLOPE_NE && track == TRACK_BIT_X) {
2114 DrawGroundSprite(ground + RTO_SLOPE_NE, PAL_NONE);
2115 if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + RTO_SLOPE_NE, PALETTE_CRASH);
2116 } else if (ti->tileh == SLOPE_SE && track == TRACK_BIT_Y) {
2117 DrawGroundSprite(ground + RTO_SLOPE_SE, PAL_NONE);
2118 if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + RTO_SLOPE_SE, PALETTE_CRASH);
2119 } else if (ti->tileh == SLOPE_SW && track == TRACK_BIT_X) {
2120 DrawGroundSprite(ground + RTO_SLOPE_SW, PAL_NONE);
2121 if (pbs != TRACK_BIT_NONE) DrawGroundSprite(overlay + RTO_SLOPE_SW, PALETTE_CRASH);
2122 } else {
2123 switch (track) {
2124 /* Draw single ground sprite when not overlapping. No track overlay
2125 * is necessary for these sprites. */
2126 case TRACK_BIT_X: DrawGroundSprite(ground + RTO_X, PAL_NONE); break;
2127 case TRACK_BIT_Y: DrawGroundSprite(ground + RTO_Y, PAL_NONE); break;
2128 case TRACK_BIT_UPPER: DrawTrackSprite(ground + RTO_N, PAL_NONE, ti, SLOPE_N); break;
2129 case TRACK_BIT_LOWER: DrawTrackSprite(ground + RTO_S, PAL_NONE, ti, SLOPE_S); break;
2130 case TRACK_BIT_RIGHT: DrawTrackSprite(ground + RTO_E, PAL_NONE, ti, SLOPE_E); break;
2131 case TRACK_BIT_LEFT: DrawTrackSprite(ground + RTO_W, PAL_NONE, ti, SLOPE_W); break;
2132 case TRACK_BIT_CROSS: DrawGroundSprite(ground + RTO_CROSSING_XY, PAL_NONE); break;
2133 case TRACK_BIT_HORZ: DrawTrackSprite(ground + RTO_N, PAL_NONE, ti, SLOPE_N);
2134 DrawTrackSprite(ground + RTO_S, PAL_NONE, ti, SLOPE_S); break;
2135 case TRACK_BIT_VERT: DrawTrackSprite(ground + RTO_E, PAL_NONE, ti, SLOPE_E);
2136 DrawTrackSprite(ground + RTO_W, PAL_NONE, ti, SLOPE_W); break;
2137
2138 default:
2139 /* We're drawing a junction tile */
2140 if ((track & TRACK_BIT_3WAY_NE) == 0) {
2141 DrawGroundSprite(ground + RTO_JUNCTION_SW, PAL_NONE);
2142 } else if ((track & TRACK_BIT_3WAY_SW) == 0) {
2143 DrawGroundSprite(ground + RTO_JUNCTION_NE, PAL_NONE);
2144 } else if ((track & TRACK_BIT_3WAY_NW) == 0) {
2145 DrawGroundSprite(ground + RTO_JUNCTION_SE, PAL_NONE);
2146 } else if ((track & TRACK_BIT_3WAY_SE) == 0) {
2147 DrawGroundSprite(ground + RTO_JUNCTION_NW, PAL_NONE);
2148 } else {
2149 DrawGroundSprite(ground + RTO_JUNCTION_NSEW, PAL_NONE);
2150 }
2151
2152 /* Mask out PBS bits as we shall draw them afterwards anyway. */
2153 track &= ~pbs;
2154
2155 /* Draw regular track bits */
2156 if (track & TRACK_BIT_X) DrawGroundSprite(overlay + RTO_X, PAL_NONE);
2157 if (track & TRACK_BIT_Y) DrawGroundSprite(overlay + RTO_Y, PAL_NONE);
2158 if (track & TRACK_BIT_UPPER) DrawGroundSprite(overlay + RTO_N, PAL_NONE);
2159 if (track & TRACK_BIT_LOWER) DrawGroundSprite(overlay + RTO_S, PAL_NONE);
2160 if (track & TRACK_BIT_RIGHT) DrawGroundSprite(overlay + RTO_E, PAL_NONE);
2161 if (track & TRACK_BIT_LEFT) DrawGroundSprite(overlay + RTO_W, PAL_NONE);
2162 }
2163
2164 /* Draw reserved track bits */
2165 if (pbs & TRACK_BIT_X) DrawGroundSprite(overlay + RTO_X, PALETTE_CRASH);
2166 if (pbs & TRACK_BIT_Y) DrawGroundSprite(overlay + RTO_Y, PALETTE_CRASH);
2167 if (pbs & TRACK_BIT_UPPER) DrawTrackSprite(overlay + RTO_N, PALETTE_CRASH, ti, SLOPE_N);
2168 if (pbs & TRACK_BIT_LOWER) DrawTrackSprite(overlay + RTO_S, PALETTE_CRASH, ti, SLOPE_S);
2169 if (pbs & TRACK_BIT_RIGHT) DrawTrackSprite(overlay + RTO_E, PALETTE_CRASH, ti, SLOPE_E);
2170 if (pbs & TRACK_BIT_LEFT) DrawTrackSprite(overlay + RTO_W, PALETTE_CRASH, ti, SLOPE_W);
2171 }
2172
2173 if (IsValidCorner(halftile_corner)) {
2174 DrawFoundation(ti, HalftileFoundation(halftile_corner));
2175 overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY, TCX_UPPER_HALFTILE);
2176 ground = GetCustomRailSprite(rti, ti->tile, RTSG_GROUND, TCX_UPPER_HALFTILE);
2177
2178 /* Draw higher halftile-overlay: Use the sloped sprites with three corners raised. They probably best fit the lightning. */
2179 Slope fake_slope = SlopeWithThreeCornersRaised(OppositeCorner(halftile_corner));
2180
2181 SpriteID image;
2182 switch (rgt) {
2183 case RAIL_GROUND_BARREN: image = SPR_FLAT_BARE_LAND; break;
2184 case RAIL_GROUND_ICE_DESERT:
2185 case RAIL_GROUND_HALF_SNOW: image = SPR_FLAT_SNOW_DESERT_TILE; break;
2186 default: image = SPR_FLAT_GRASS_TILE; break;
2187 }
2188
2189 image += SlopeToSpriteOffset(fake_slope);
2190
2191 DrawGroundSprite(image, PAL_NONE, &(_halftile_sub_sprite[halftile_corner]));
2192
2193 track = CornerToTrackBits(halftile_corner);
2194
2195 int offset;
2196 switch (track) {
2197 default: NOT_REACHED();
2198 case TRACK_BIT_UPPER: offset = RTO_N; break;
2199 case TRACK_BIT_LOWER: offset = RTO_S; break;
2200 case TRACK_BIT_RIGHT: offset = RTO_E; break;
2201 case TRACK_BIT_LEFT: offset = RTO_W; break;
2202 }
2203
2204 DrawTrackSprite(ground + offset, PAL_NONE, ti, fake_slope);
2205 if (_settings_client.gui.show_track_reservation && HasReservedTracks(ti->tile, track)) {
2206 DrawTrackSprite(overlay + offset, PALETTE_CRASH, ti, fake_slope);
2207 }
2208 }
2209 }
2210
2216 static void DrawTrackBits(TileInfo *ti, TrackBits track)
2217 {
2218 const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
2219
2220 if (rti->UsesOverlay()) {
2221 DrawTrackBitsOverlay(ti, track, rti);
2222 return;
2223 }
2224
2225 RailGroundType rgt = GetRailGroundType(ti->tile);
2226 Foundation f = GetRailFoundation(ti->tileh, track);
2227 Corner halftile_corner = CORNER_INVALID;
2228
2229 if (IsNonContinuousFoundation(f)) {
2230 /* Save halftile corner */
2231 halftile_corner = (f == FOUNDATION_STEEP_BOTH ? GetHighestSlopeCorner(ti->tileh) : GetHalftileFoundationCorner(f));
2232 /* Draw lower part first */
2233 track &= ~CornerToTrackBits(halftile_corner);
2234 f = (f == FOUNDATION_STEEP_BOTH ? FOUNDATION_STEEP_LOWER : FOUNDATION_NONE);
2235 }
2236
2237 DrawFoundation(ti, f);
2238 /* DrawFoundation modifies ti */
2239
2240 SpriteID image;
2241 PaletteID pal = PAL_NONE;
2242 const SubSprite *sub = NULL;
2243 bool junction = false;
2244
2245 /* Select the sprite to use. */
2246 if (track == 0) {
2247 /* Clear ground (only track on halftile foundation) */
2248 if (rgt == RAIL_GROUND_WATER) {
2249 if (IsSteepSlope(ti->tileh)) {
2250 DrawShoreTile(ti->tileh);
2251 image = 0;
2252 } else {
2253 image = SPR_FLAT_WATER_TILE;
2254 }
2255 } else {
2256 switch (rgt) {
2257 case RAIL_GROUND_BARREN: image = SPR_FLAT_BARE_LAND; break;
2258 case RAIL_GROUND_ICE_DESERT: image = SPR_FLAT_SNOW_DESERT_TILE; break;
2259 default: image = SPR_FLAT_GRASS_TILE; break;
2260 }
2261 image += SlopeToSpriteOffset(ti->tileh);
2262 }
2263 } else {
2264 if (ti->tileh != SLOPE_FLAT) {
2265 /* track on non-flat ground */
2266 image = _track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.track_y;
2267 } else {
2268 /* track on flat ground */
2269 (image = rti->base_sprites.track_y, track == TRACK_BIT_Y) ||
2270 (image++, track == TRACK_BIT_X) ||
2271 (image++, track == TRACK_BIT_UPPER) ||
2272 (image++, track == TRACK_BIT_LOWER) ||
2273 (image++, track == TRACK_BIT_RIGHT) ||
2274 (image++, track == TRACK_BIT_LEFT) ||
2275 (image++, track == TRACK_BIT_CROSS) ||
2276
2277 (image = rti->base_sprites.track_ns, track == TRACK_BIT_HORZ) ||
2278 (image++, track == TRACK_BIT_VERT) ||
2279
2280 (junction = true, false) ||
2281 (image = rti->base_sprites.ground, (track & TRACK_BIT_3WAY_NE) == 0) ||
2282 (image++, (track & TRACK_BIT_3WAY_SW) == 0) ||
2283 (image++, (track & TRACK_BIT_3WAY_NW) == 0) ||
2284 (image++, (track & TRACK_BIT_3WAY_SE) == 0) ||
2285 (image++, true);
2286 }
2287
2288 switch (rgt) {
2289 case RAIL_GROUND_BARREN: pal = PALETTE_TO_BARE_LAND; break;
2290 case RAIL_GROUND_ICE_DESERT: image += rti->snow_offset; break;
2291 case RAIL_GROUND_WATER: {
2292 /* three-corner-raised slope */
2293 DrawShoreTile(ti->tileh);
2294 Corner track_corner = OppositeCorner(GetHighestSlopeCorner(ComplementSlope(ti->tileh)));
2295 sub = &(_halftile_sub_sprite[track_corner]);
2296 break;
2297 }
2298 default: break;
2299 }
2300 }
2301
2302 if (image != 0) DrawGroundSprite(image, pal, sub);
2303
2304 /* Draw track pieces individually for junction tiles */
2305 if (junction) {
2306 if (track & TRACK_BIT_X) DrawGroundSprite(rti->base_sprites.single_x, PAL_NONE);
2307 if (track & TRACK_BIT_Y) DrawGroundSprite(rti->base_sprites.single_y, PAL_NONE);
2308 if (track & TRACK_BIT_UPPER) DrawGroundSprite(rti->base_sprites.single_n, PAL_NONE);
2309 if (track & TRACK_BIT_LOWER) DrawGroundSprite(rti->base_sprites.single_s, PAL_NONE);
2310 if (track & TRACK_BIT_LEFT) DrawGroundSprite(rti->base_sprites.single_w, PAL_NONE);
2311 if (track & TRACK_BIT_RIGHT) DrawGroundSprite(rti->base_sprites.single_e, PAL_NONE);
2312 }
2313
2314 /* PBS debugging, draw reserved tracks darker */
2315 if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation) {
2316 /* Get reservation, but mask track on halftile slope */
2317 TrackBits pbs = GetRailReservationTrackBits(ti->tile) & track;
2318 if (pbs & TRACK_BIT_X) {
2319 if (ti->tileh == SLOPE_FLAT || ti->tileh == SLOPE_ELEVATED) {
2320 DrawGroundSprite(rti->base_sprites.single_x, PALETTE_CRASH);
2321 } else {
2322 DrawGroundSprite(_track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.single_sloped - 20, PALETTE_CRASH);
2323 }
2324 }
2325 if (pbs & TRACK_BIT_Y) {
2326 if (ti->tileh == SLOPE_FLAT || ti->tileh == SLOPE_ELEVATED) {
2327 DrawGroundSprite(rti->base_sprites.single_y, PALETTE_CRASH);
2328 } else {
2329 DrawGroundSprite(_track_sloped_sprites[ti->tileh - 1] + rti->base_sprites.single_sloped - 20, PALETTE_CRASH);
2330 }
2331 }
2332 if (pbs & TRACK_BIT_UPPER) DrawGroundSprite(rti->base_sprites.single_n, PALETTE_CRASH, NULL, 0, ti->tileh & SLOPE_N ? -(int)TILE_HEIGHT : 0);
2333 if (pbs & TRACK_BIT_LOWER) DrawGroundSprite(rti->base_sprites.single_s, PALETTE_CRASH, NULL, 0, ti->tileh & SLOPE_S ? -(int)TILE_HEIGHT : 0);
2334 if (pbs & TRACK_BIT_LEFT) DrawGroundSprite(rti->base_sprites.single_w, PALETTE_CRASH, NULL, 0, ti->tileh & SLOPE_W ? -(int)TILE_HEIGHT : 0);
2335 if (pbs & TRACK_BIT_RIGHT) DrawGroundSprite(rti->base_sprites.single_e, PALETTE_CRASH, NULL, 0, ti->tileh & SLOPE_E ? -(int)TILE_HEIGHT : 0);
2336 }
2337
2338 if (IsValidCorner(halftile_corner)) {
2339 DrawFoundation(ti, HalftileFoundation(halftile_corner));
2340
2341 /* Draw higher halftile-overlay: Use the sloped sprites with three corners raised. They probably best fit the lightning. */
2342 Slope fake_slope = SlopeWithThreeCornersRaised(OppositeCorner(halftile_corner));
2343 image = _track_sloped_sprites[fake_slope - 1] + rti->base_sprites.track_y;
2344 pal = PAL_NONE;
2345 switch (rgt) {
2346 case RAIL_GROUND_BARREN: pal = PALETTE_TO_BARE_LAND; break;
2347 case RAIL_GROUND_ICE_DESERT:
2348 case RAIL_GROUND_HALF_SNOW: image += rti->snow_offset; break; // higher part has snow in this case too
2349 default: break;
2350 }
2351 DrawGroundSprite(image, pal, &(_halftile_sub_sprite[halftile_corner]));
2352
2353 if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasReservedTracks(ti->tile, CornerToTrackBits(halftile_corner))) {
2354 static const byte _corner_to_track_sprite[] = {3, 1, 2, 0};
2355 DrawGroundSprite(_corner_to_track_sprite[halftile_corner] + rti->base_sprites.single_n, PALETTE_CRASH, NULL, 0, -(int)TILE_HEIGHT);
2356 }
2357 }
2358 }
2359
2360 static void DrawSignals(TileIndex tile, TrackBits rails, const RailtypeInfo *rti)
2361 {
2362 #define MAYBE_DRAW_SIGNAL(x, y, z, t) if (IsSignalPresent(tile, x)) DrawSingleSignal(tile, rti, t, GetSingleSignalState(tile, x), y, z)
2363
2364 if (!(rails & TRACK_BIT_Y)) {
2365 if (!(rails & TRACK_BIT_X)) {
2366 if (rails & TRACK_BIT_LEFT) {
2367 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_NORTH, 0, TRACK_LEFT);
2368 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_SOUTH, 1, TRACK_LEFT);
2369 }
2370 if (rails & TRACK_BIT_RIGHT) {
2371 MAYBE_DRAW_SIGNAL(0, SIGNAL_TO_NORTH, 2, TRACK_RIGHT);
2372 MAYBE_DRAW_SIGNAL(1, SIGNAL_TO_SOUTH, 3, TRACK_RIGHT);
2373 }
2374 if (rails & TRACK_BIT_UPPER) {
2375 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_WEST, 4, TRACK_UPPER);
2376 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_EAST, 5, TRACK_UPPER);
2377 }
2378 if (rails & TRACK_BIT_LOWER) {
2379 MAYBE_DRAW_SIGNAL(1, SIGNAL_TO_WEST, 6, TRACK_LOWER);
2380 MAYBE_DRAW_SIGNAL(0, SIGNAL_TO_EAST, 7, TRACK_LOWER);
2381 }
2382 } else {
2383 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_SOUTHWEST, 8, TRACK_X);
2384 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_NORTHEAST, 9, TRACK_X);
2385 }
2386 } else {
2387 MAYBE_DRAW_SIGNAL(3, SIGNAL_TO_SOUTHEAST, 10, TRACK_Y);
2388 MAYBE_DRAW_SIGNAL(2, SIGNAL_TO_NORTHWEST, 11, TRACK_Y);
2389 }
2390 }
2391
2392 static void DrawTile_Track(TileInfo *ti)
2393 {
2394 const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(ti->tile));
2395
2396 _drawtile_track_palette = COMPANY_SPRITE_COLOUR(GetTileOwner(ti->tile));
2397
2398 if (IsPlainRail(ti->tile)) {
2399 TrackBits rails = GetTrackBits(ti->tile);
2400
2401 DrawTrackBits(ti, rails);
2402
2403 if (HasBit(_display_opt, DO_FULL_DETAIL)) DrawTrackDetails(ti, rti);
2404
2405 if (HasRailCatenaryDrawn(GetRailType(ti->tile))) DrawRailCatenary(ti);
2406
2407 if (HasSignals(ti->tile)) DrawSignals(ti->tile, rails, rti);
2408 } else {
2409 /* draw depot */
2410 const DrawTileSprites *dts;
2411 PaletteID pal = PAL_NONE;
2412 SpriteID relocation;
2413
2414 if (ti->tileh != SLOPE_FLAT) DrawFoundation(ti, FOUNDATION_LEVELED);
2415
2416 if (IsInvisibilitySet(TO_BUILDINGS)) {
2417 /* Draw rail instead of depot */
2418 dts = &_depot_invisible_gfx_table[GetRailDepotDirection(ti->tile)];
2419 } else {
2420 dts = &_depot_gfx_table[GetRailDepotDirection(ti->tile)];
2421 }
2422
2423 SpriteID image;
2424 if (rti->UsesOverlay()) {
2425 image = SPR_FLAT_GRASS_TILE;
2426 } else {
2427 image = dts->ground.sprite;
2428 if (image != SPR_FLAT_GRASS_TILE) image += rti->GetRailtypeSpriteOffset();
2429 }
2430
2431 /* adjust ground tile for desert
2432 * don't adjust for snow, because snow in depots looks weird */
2433 if (IsSnowRailGround(ti->tile) && _settings_game.game_creation.landscape == LT_TROPIC) {
2434 if (image != SPR_FLAT_GRASS_TILE) {
2435 image += rti->snow_offset; // tile with tracks
2436 } else {
2437 image = SPR_FLAT_SNOW_DESERT_TILE; // flat ground
2438 }
2439 }
2440
2441 DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, _drawtile_track_palette));
2442
2443 if (rti->UsesOverlay()) {
2444 SpriteID ground = GetCustomRailSprite(rti, ti->tile, RTSG_GROUND);
2445
2446 switch (GetRailDepotDirection(ti->tile)) {
2447 case DIAGDIR_NE:
2448 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2449 FALLTHROUGH;
2450 case DIAGDIR_SW:
2451 DrawGroundSprite(ground + RTO_X, PAL_NONE);
2452 break;
2453 case DIAGDIR_NW:
2454 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2455 FALLTHROUGH;
2456 case DIAGDIR_SE:
2457 DrawGroundSprite(ground + RTO_Y, PAL_NONE);
2458 break;
2459 default:
2460 break;
2461 }
2462
2463 if (_settings_client.gui.show_track_reservation && HasDepotReservation(ti->tile)) {
2464 SpriteID overlay = GetCustomRailSprite(rti, ti->tile, RTSG_OVERLAY);
2465
2466 switch (GetRailDepotDirection(ti->tile)) {
2467 case DIAGDIR_NE:
2468 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2469 FALLTHROUGH;
2470 case DIAGDIR_SW:
2471 DrawGroundSprite(overlay + RTO_X, PALETTE_CRASH);
2472 break;
2473 case DIAGDIR_NW:
2474 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2475 FALLTHROUGH;
2476 case DIAGDIR_SE:
2477 DrawGroundSprite(overlay + RTO_Y, PALETTE_CRASH);
2478 break;
2479 default:
2480 break;
2481 }
2482 }
2483 } else {
2484 /* PBS debugging, draw reserved tracks darker */
2485 if (_game_mode != GM_MENU && _settings_client.gui.show_track_reservation && HasDepotReservation(ti->tile)) {
2486 switch (GetRailDepotDirection(ti->tile)) {
2487 case DIAGDIR_NE:
2488 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2489 FALLTHROUGH;
2490 case DIAGDIR_SW:
2491 DrawGroundSprite(rti->base_sprites.single_x, PALETTE_CRASH);
2492 break;
2493 case DIAGDIR_NW:
2494 if (!IsInvisibilitySet(TO_BUILDINGS)) break;
2495 FALLTHROUGH;
2496 case DIAGDIR_SE:
2497 DrawGroundSprite(rti->base_sprites.single_y, PALETTE_CRASH);
2498 break;
2499 default:
2500 break;
2501 }
2502 }
2503 }
2504 int depot_sprite = GetCustomRailSprite(rti, ti->tile, RTSG_DEPOT);
2505 relocation = depot_sprite != 0 ? depot_sprite - SPR_RAIL_DEPOT_SE_1 : rti->GetRailtypeSpriteOffset();
2506
2507 if (HasRailCatenaryDrawn(GetRailType(ti->tile))) DrawRailCatenary(ti);
2508
2509 DrawRailTileSeq(ti, dts, TO_BUILDINGS, relocation, 0, _drawtile_track_palette);
2510 }
2511 DrawBridgeMiddle(ti);
2512 }
2513
2514 void DrawTrainDepotSprite(int x, int y, int dir, RailType railtype)
2515 {
2516 const DrawTileSprites *dts = &_depot_gfx_table[dir];
2517 const RailtypeInfo *rti = GetRailTypeInfo(railtype);
2518 SpriteID image = rti->UsesOverlay() ? SPR_FLAT_GRASS_TILE : dts->ground.sprite;
2519 uint32 offset = rti->GetRailtypeSpriteOffset();
2520
2521 if (image != SPR_FLAT_GRASS_TILE) image += offset;
2522 PaletteID palette = COMPANY_SPRITE_COLOUR(_local_company);
2523
2524 DrawSprite(image, PAL_NONE, x, y);
2525
2526 if (rti->UsesOverlay()) {
2527 SpriteID ground = GetCustomRailSprite(rti, INVALID_TILE, RTSG_GROUND);
2528
2529 switch (dir) {
2530 case DIAGDIR_SW: DrawSprite(ground + RTO_X, PAL_NONE, x, y); break;
2531 case DIAGDIR_SE: DrawSprite(ground + RTO_Y, PAL_NONE, x, y); break;
2532 default: break;
2533 }
2534 }
2535 int depot_sprite = GetCustomRailSprite(rti, INVALID_TILE, RTSG_DEPOT);
2536 if (depot_sprite != 0) offset = depot_sprite - SPR_RAIL_DEPOT_SE_1;
2537
2538 DrawRailTileSeqInGUI(x, y, dts, offset, 0, palette);
2539 }
2540
2541 static int GetSlopePixelZ_Track(TileIndex tile, uint x, uint y)
2542 {
2543 if (IsPlainRail(tile)) {
2544 int z;
2545 Slope tileh = GetTilePixelSlope(tile, &z);
2546 if (tileh == SLOPE_FLAT) return z;
2547
2548 z += ApplyPixelFoundationToSlope(GetRailFoundation(tileh, GetTrackBits(tile)), &tileh);
2549 return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
2550 } else {
2551 return GetTileMaxPixelZ(tile);
2552 }
2553 }
2554
2555 static Foundation GetFoundation_Track(TileIndex tile, Slope tileh)
2556 {
2557 return IsPlainRail(tile) ? GetRailFoundation(tileh, GetTrackBits(tile)) : FlatteningFoundation(tileh);
2558 }
2559
2560 static void TileLoop_Track(TileIndex tile)
2561 {
2562 RailGroundType old_ground = GetRailGroundType(tile);
2563 RailGroundType new_ground;
2564
2565 if (old_ground == RAIL_GROUND_WATER) {
2566 TileLoop_Water(tile);
2567 return;
2568 }
2569
2570 switch (_settings_game.game_creation.landscape) {
2571 case LT_ARCTIC: {
2572 int z;
2573 Slope slope = GetTileSlope(tile, &z);
2574 bool half = false;
2575
2576 /* for non-flat track, use lower part of track
2577 * in other cases, use the highest part with track */
2578 if (IsPlainRail(tile)) {
2579 TrackBits track = GetTrackBits(tile);
2580 Foundation f = GetRailFoundation(slope, track);
2581
2582 switch (f) {
2583 case FOUNDATION_NONE:
2584 /* no foundation - is the track on the upper side of three corners raised tile? */
2585 if (IsSlopeWithThreeCornersRaised(slope)) z++;
2586 break;
2587
2588 case FOUNDATION_INCLINED_X:
2589 case FOUNDATION_INCLINED_Y:
2590 /* sloped track - is it on a steep slope? */
2591 if (IsSteepSlope(slope)) z++;
2592 break;
2593
2594 case FOUNDATION_STEEP_LOWER:
2595 /* only lower part of steep slope */
2596 z++;
2597 break;
2598
2599 default:
2600 /* if it is a steep slope, then there is a track on higher part */
2601 if (IsSteepSlope(slope)) z++;
2602 z++;
2603 break;
2604 }
2605
2606 half = IsInsideMM(f, FOUNDATION_STEEP_BOTH, FOUNDATION_HALFTILE_N + 1);
2607 } else {
2608 /* is the depot on a non-flat tile? */
2609 if (slope != SLOPE_FLAT) z++;
2610 }
2611
2612 /* 'z' is now the lowest part of the highest track bit -
2613 * for sloped track, it is 'z' of lower part
2614 * for two track bits, it is 'z' of higher track bit
2615 * For non-continuous foundations (and STEEP_BOTH), 'half' is set */
2616 if (z > GetSnowLine()) {
2617 if (half && z - GetSnowLine() == 1) {
2618 /* track on non-continuous foundation, lower part is not under snow */
2619 new_ground = RAIL_GROUND_HALF_SNOW;
2620 } else {
2621 new_ground = RAIL_GROUND_ICE_DESERT;
2622 }
2623 goto set_ground;
2624 }
2625 break;
2626 }
2627
2628 case LT_TROPIC:
2629 if (GetTropicZone(tile) == TROPICZONE_DESERT) {
2630 new_ground = RAIL_GROUND_ICE_DESERT;
2631 goto set_ground;
2632 }
2633 break;
2634 }
2635
2636 new_ground = RAIL_GROUND_GRASS;
2637
2638 if (IsPlainRail(tile) && old_ground != RAIL_GROUND_BARREN) { // wait until bottom is green
2639 /* determine direction of fence */
2640 TrackBits rail = GetTrackBits(tile);
2641
2642 Owner owner = GetTileOwner(tile);
2643 byte fences = 0;
2644
2645 for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
2646 static const TrackBits dir_to_trackbits[DIAGDIR_END] = {TRACK_BIT_3WAY_NE, TRACK_BIT_3WAY_SE, TRACK_BIT_3WAY_SW, TRACK_BIT_3WAY_NW};
2647
2648 /* Track bit on this edge => no fence. */
2649 if ((rail & dir_to_trackbits[d]) != TRACK_BIT_NONE) continue;
2650
2651 TileIndex tile2 = tile + TileOffsByDiagDir(d);
2652
2653 /* Show fences if it's a house, industry, object, road, tunnelbridge or not owned by us. */
2654 if (!IsValidTile(tile2) || IsTileType(tile2, MP_HOUSE) || IsTileType(tile2, MP_INDUSTRY) ||
2655 IsTileType(tile2, MP_ROAD) || (IsTileType(tile2, MP_OBJECT) && !IsObjectType(tile2, OBJECT_OWNED_LAND)) || IsTileType(tile2, MP_TUNNELBRIDGE) || !IsTileOwner(tile2, owner)) {
2656 fences |= 1 << d;
2657 }
2658 }
2659
2660 switch (fences) {
2661 case 0: break;
2662 case (1 << DIAGDIR_NE): new_ground = RAIL_GROUND_FENCE_NE; break;
2663 case (1 << DIAGDIR_SE): new_ground = RAIL_GROUND_FENCE_SE; break;
2664 case (1 << DIAGDIR_SW): new_ground = RAIL_GROUND_FENCE_SW; break;
2665 case (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_NW; break;
2666 case (1 << DIAGDIR_NE) | (1 << DIAGDIR_SW): new_ground = RAIL_GROUND_FENCE_NESW; break;
2667 case (1 << DIAGDIR_SE) | (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_SENW; break;
2668 case (1 << DIAGDIR_NE) | (1 << DIAGDIR_SE): new_ground = RAIL_GROUND_FENCE_VERT1; break;
2669 case (1 << DIAGDIR_NE) | (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_HORIZ2; break;
2670 case (1 << DIAGDIR_SE) | (1 << DIAGDIR_SW): new_ground = RAIL_GROUND_FENCE_HORIZ1; break;
2671 case (1 << DIAGDIR_SW) | (1 << DIAGDIR_NW): new_ground = RAIL_GROUND_FENCE_VERT2; break;
2672 default: NOT_REACHED();
2673 }
2674 }
2675
2676 set_ground:
2677 if (old_ground != new_ground) {
2678 SetRailGroundType(tile, new_ground);
2679 MarkTileDirtyByTile(tile);
2680 }
2681 }
2682
2683
2684 static TrackStatus GetTileTrackStatus_Track(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
2685 {
2686 /* Case of half tile slope with water. */
2687 if (mode == TRANSPORT_WATER && IsPlainRail(tile) && GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(GetTileSlope(tile))) {
2688 TrackBits tb = GetTrackBits(tile);
2689 switch (tb) {
2690 default: NOT_REACHED();
2691 case TRACK_BIT_UPPER: tb = TRACK_BIT_LOWER; break;
2692 case TRACK_BIT_LOWER: tb = TRACK_BIT_UPPER; break;
2693 case TRACK_BIT_LEFT: tb = TRACK_BIT_RIGHT; break;
2694 case TRACK_BIT_RIGHT: tb = TRACK_BIT_LEFT; break;
2695 }
2696 return CombineTrackStatus(TrackBitsToTrackdirBits(tb), TRACKDIR_BIT_NONE);
2697 }
2698
2699 if (mode != TRANSPORT_RAIL) return 0;
2700
2701 TrackBits trackbits = TRACK_BIT_NONE;
2702 TrackdirBits red_signals = TRACKDIR_BIT_NONE;
2703
2704 switch (GetRailTileType(tile)) {
2705 default: NOT_REACHED();
2706 case RAIL_TILE_NORMAL:
2707 trackbits = GetTrackBits(tile);
2708 break;
2709
2710 case RAIL_TILE_SIGNALS: {
2711 trackbits = GetTrackBits(tile);
2712 byte a = GetPresentSignals(tile);
2713 uint b = GetSignalStates(tile);
2714
2715 b &= a;
2716
2717 /* When signals are not present (in neither direction),
2718 * we pretend them to be green. Otherwise, it depends on
2719 * the signal type. For signals that are only active from
2720 * one side, we set the missing signals explicitly to
2721 * `green'. Otherwise, they implicitly become `red'. */
2722 if (!IsOnewaySignal(tile, TRACK_UPPER) || (a & SignalOnTrack(TRACK_UPPER)) == 0) b |= ~a & SignalOnTrack(TRACK_UPPER);
2723 if (!IsOnewaySignal(tile, TRACK_LOWER) || (a & SignalOnTrack(TRACK_LOWER)) == 0) b |= ~a & SignalOnTrack(TRACK_LOWER);
2724
2725 if ((b & 0x8) == 0) red_signals |= (TRACKDIR_BIT_LEFT_N | TRACKDIR_BIT_X_NE | TRACKDIR_BIT_Y_SE | TRACKDIR_BIT_UPPER_E);
2726 if ((b & 0x4) == 0) red_signals |= (TRACKDIR_BIT_LEFT_S | TRACKDIR_BIT_X_SW | TRACKDIR_BIT_Y_NW | TRACKDIR_BIT_UPPER_W);
2727 if ((b & 0x2) == 0) red_signals |= (TRACKDIR_BIT_RIGHT_N | TRACKDIR_BIT_LOWER_E);
2728 if ((b & 0x1) == 0) red_signals |= (TRACKDIR_BIT_RIGHT_S | TRACKDIR_BIT_LOWER_W);
2729
2730 break;
2731 }
2732
2733 case RAIL_TILE_DEPOT: {
2734 DiagDirection dir = GetRailDepotDirection(tile);
2735
2736 if (side != INVALID_DIAGDIR && side != dir) break;
2737
2738 trackbits = DiagDirToDiagTrackBits(dir);
2739 break;
2740 }
2741 }
2742
2743 return CombineTrackStatus(TrackBitsToTrackdirBits(trackbits), red_signals);
2744 }
2745
2746 static bool ClickTile_Track(TileIndex tile)
2747 {
2748 if (!IsRailDepot(tile)) return false;
2749
2750 ShowDepotWindow(tile, VEH_TRAIN);
2751 return true;
2752 }
2753
2754 static void GetTileDesc_Track(TileIndex tile, TileDesc *td)
2755 {
2756 const RailtypeInfo *rti = GetRailTypeInfo(GetRailType(tile));
2757 td->rail_speed = rti->max_speed;
2758 td->railtype = rti->strings.name;
2759 td->owner[0] = GetTileOwner(tile);
2760 switch (GetRailTileType(tile)) {
2761 case RAIL_TILE_NORMAL:
2762 td->str = STR_LAI_RAIL_DESCRIPTION_TRACK;
2763 break;
2764
2765 case RAIL_TILE_SIGNALS: {
2766 static const StringID signal_type[6][6] = {
2767 {
2768 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_SIGNALS,
2769 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PRESIGNALS,
2770 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_EXITSIGNALS,
2771 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_COMBOSIGNALS,
2772 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PBSSIGNALS,
2773 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_NOENTRYSIGNALS
2774 },
2775 {
2776 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PRESIGNALS,
2777 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRESIGNALS,
2778 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_EXITSIGNALS,
2779 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_COMBOSIGNALS,
2780 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_PBSSIGNALS,
2781 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_NOENTRYSIGNALS
2782 },
2783 {
2784 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_EXITSIGNALS,
2785 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_EXITSIGNALS,
2786 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXITSIGNALS,
2787 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_COMBOSIGNALS,
2788 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_PBSSIGNALS,
2789 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_NOENTRYSIGNALS
2790 },
2791 {
2792 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_COMBOSIGNALS,
2793 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_COMBOSIGNALS,
2794 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_COMBOSIGNALS,
2795 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBOSIGNALS,
2796 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_PBSSIGNALS,
2797 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_NOENTRYSIGNALS
2798 },
2799 {
2800 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_PBSSIGNALS,
2801 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_PBSSIGNALS,
2802 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_PBSSIGNALS,
2803 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_PBSSIGNALS,
2804 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PBSSIGNALS,
2805 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PBS_NOENTRYSIGNALS
2806 },
2807 {
2808 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NORMAL_NOENTRYSIGNALS,
2809 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PRE_NOENTRYSIGNALS,
2810 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_EXIT_NOENTRYSIGNALS,
2811 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_COMBO_NOENTRYSIGNALS,
2812 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_PBS_NOENTRYSIGNALS,
2813 STR_LAI_RAIL_DESCRIPTION_TRACK_WITH_NOENTRYSIGNALS
2814 }
2815 };
2816
2817 SignalType primary_signal;
2818 SignalType secondary_signal;
2819 if (HasSignalOnTrack(tile, TRACK_UPPER)) {
2820 primary_signal = GetSignalType(tile, TRACK_UPPER);
2821 secondary_signal = HasSignalOnTrack(tile, TRACK_LOWER) ? GetSignalType(tile, TRACK_LOWER) : primary_signal;
2822 } else {
2823 secondary_signal = primary_signal = GetSignalType(tile, TRACK_LOWER);
2824 }
2825
2826 td->str = signal_type[secondary_signal][primary_signal];
2827 break;
2828 }
2829
2830 case RAIL_TILE_DEPOT:
2831 td->str = STR_LAI_RAIL_DESCRIPTION_TRAIN_DEPOT;
2832 if (_settings_game.vehicle.train_acceleration_model != AM_ORIGINAL) {
2833 if (td->rail_speed > 0) {
2834 td->rail_speed = min(td->rail_speed, 61);
2835 } else {
2836 td->rail_speed = 61;
2837 }
2838 }
2839 td->build_date = Depot::GetByTile(tile)->build_date;
2840 break;
2841
2842 default:
2843 NOT_REACHED();
2844 }
2845 }
2846
2847 static void ChangeTileOwner_Track(TileIndex tile, Owner old_owner, Owner new_owner)
2848 {
2849 if (!IsTileOwner(tile, old_owner)) return;
2850
2851 if (new_owner != INVALID_OWNER) {
2852 /* Update company infrastructure counts. No need to dirty windows here, we'll redraw the whole screen anyway. */
2853 uint num_pieces = 1;
2854 if (IsPlainRail(tile)) {
2855 TrackBits bits = GetTrackBits(tile);
2856 num_pieces = CountBits(bits);
2857 if (TracksOverlap(bits)) num_pieces *= num_pieces;
2858 }
2859 RailType rt = GetRailType(tile);
2860 Company::Get(old_owner)->infrastructure.rail[rt] -= num_pieces;
2861 Company::Get(new_owner)->infrastructure.rail[rt] += num_pieces;
2862
2863 if (HasSignals(tile)) {
2864 uint num_sigs = CountBits(GetPresentSignals(tile));
2865 Company::Get(old_owner)->infrastructure.signal -= num_sigs;
2866 Company::Get(new_owner)->infrastructure.signal += num_sigs;
2867 }
2868
2869 SetTileOwner(tile, new_owner);
2870 } else {
2871 DoCommand(tile, 0, 0, DC_EXEC | DC_BANKRUPT, CMD_LANDSCAPE_CLEAR);
2872 }
2873 }
2874
2875 static const byte _fractcoords_behind[4] = { 0x8F, 0x8, 0x80, 0xF8 };
2876 static const byte _fractcoords_enter[4] = { 0x8A, 0x48, 0x84, 0xA8 };
2877 static const int8 _deltacoord_leaveoffset[8] = {
2878 -1, 0, 1, 0, /* x */
2879 0, 1, 0, -1 /* y */
2880 };
2881
2882
2889 int TicksToLeaveDepot(const Train *v)
2890 {
2891 DiagDirection dir = GetRailDepotDirection(v->tile);
2892 int length = v->CalcNextVehicleOffset();
2893
2894 switch (dir) {
2895 case DIAGDIR_NE: return ((int)(v->x_pos & 0x0F) - ((_fractcoords_enter[dir] & 0x0F) - (length + 1)));
2896 case DIAGDIR_SE: return -((int)(v->y_pos & 0x0F) - ((_fractcoords_enter[dir] >> 4) + (length + 1)));
2897 case DIAGDIR_SW: return -((int)(v->x_pos & 0x0F) - ((_fractcoords_enter[dir] & 0x0F) + (length + 1)));
2898 default:
2899 case DIAGDIR_NW: return ((int)(v->y_pos & 0x0F) - ((_fractcoords_enter[dir] >> 4) - (length + 1)));
2900 }
2901
2902 return 0; // make compilers happy
2903 }
2904
2909 static VehicleEnterTileStatus VehicleEnter_Track(Vehicle *u, TileIndex tile, int x, int y)
2910 {
2911 /* this routine applies only to trains in depot tiles */
2912 if (u->type != VEH_TRAIN || !IsRailDepotTile(tile)) return VETSB_CONTINUE;
2913
2914 Train *v = Train::From(u);
2915
2916 /* depot direction */
2917 DiagDirection dir = GetRailDepotDirection(tile);
2918
2919 /* Calculate the point where the following wagon should be activated. */
2920 int length = v->CalcNextVehicleOffset();
2921
2922 byte fract_coord_leave =
2923 ((_fractcoords_enter[dir] & 0x0F) + // x
2924 (length + 1) * _deltacoord_leaveoffset[dir]) +
2925 (((_fractcoords_enter[dir] >> 4) + // y
2926 ((length + 1) * _deltacoord_leaveoffset[dir + 4])) << 4);
2927
2928 byte fract_coord = (x & 0xF) + ((y & 0xF) << 4);
2929
2930 if (_fractcoords_behind[dir] == fract_coord) {
2931 /* make sure a train is not entering the tile from behind */
2932 return VETSB_CANNOT_ENTER;
2933 } else if (_fractcoords_enter[dir] == fract_coord) {
2934 if (DiagDirToDir(ReverseDiagDir(dir)) == v->direction) {
2935 /* enter the depot */
2936 v->track = TRACK_BIT_DEPOT,
2937 v->vehstatus |= VS_HIDDEN; // hide it
2938 v->direction = ReverseDir(v->direction);
2939 if (v->Next() == NULL) VehicleEnterDepot(v->First());
2940 v->tile = tile;
2941
2942 InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
2943 return VETSB_ENTERED_WORMHOLE;
2944 }
2945 } else if (fract_coord_leave == fract_coord) {
2946 if (DiagDirToDir(dir) == v->direction) {
2947 /* leave the depot? */
2948 if ((v = v->Next()) != NULL) {
2949 v->vehstatus &= ~VS_HIDDEN;
2950 v->track = (DiagDirToAxis(dir) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y);
2951 }
2952 }
2953 }
2954
2955 return VETSB_CONTINUE;
2956 }
2957
2969 static CommandCost TestAutoslopeOnRailTile(TileIndex tile, uint flags, int z_old, Slope tileh_old, int z_new, Slope tileh_new, TrackBits rail_bits)
2970 {
2971 if (!_settings_game.construction.build_on_slopes || !AutoslopeEnabled()) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
2972
2973 /* Is the slope-rail_bits combination valid in general? I.e. is it safe to call GetRailFoundation() ? */
2974 if (CheckRailSlope(tileh_new, rail_bits, TRACK_BIT_NONE, tile).Failed()) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
2975
2976 /* Get the slopes on top of the foundations */
2977 z_old += ApplyFoundationToSlope(GetRailFoundation(tileh_old, rail_bits), &tileh_old);
2978 z_new += ApplyFoundationToSlope(GetRailFoundation(tileh_new, rail_bits), &tileh_new);
2979
2980 Corner track_corner;
2981 switch (rail_bits) {
2982 case TRACK_BIT_LEFT: track_corner = CORNER_W; break;
2983 case TRACK_BIT_LOWER: track_corner = CORNER_S; break;
2984 case TRACK_BIT_RIGHT: track_corner = CORNER_E; break;
2985 case TRACK_BIT_UPPER: track_corner = CORNER_N; break;
2986
2987 /* Surface slope must not be changed */
2988 default:
2989 if (z_old != z_new || tileh_old != tileh_new) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
2990 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
2991 }
2992
2993 /* The height of the track_corner must not be changed. The rest ensures GetRailFoundation() already. */
2994 z_old += GetSlopeZInCorner(RemoveHalftileSlope(tileh_old), track_corner);
2995 z_new += GetSlopeZInCorner(RemoveHalftileSlope(tileh_new), track_corner);
2996 if (z_old != z_new) return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);
2997
2998 CommandCost cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
2999 /* Make the ground dirty, if surface slope has changed */
3000 if (tileh_old != tileh_new) {
3001 /* If there is flat water on the lower halftile add the cost for clearing it */
3002 if (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh_old)) cost.AddCost(_price[PR_CLEAR_WATER]);
3003 if ((flags & DC_EXEC) != 0) SetRailGroundType(tile, RAIL_GROUND_BARREN);
3004 }
3005 return cost;
3006 }
3007
3011 static Vehicle *EnsureNoShipProc(Vehicle *v, void *data)
3012 {
3013 return v->type == VEH_SHIP ? v : NULL;
3014 }
3015
3016 static CommandCost TerraformTile_Track(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)
3017 {
3018 int z_old;
3019 Slope tileh_old = GetTileSlope(tile, &z_old);
3020 if (IsPlainRail(tile)) {
3021 TrackBits rail_bits = GetTrackBits(tile);
3022 /* Is there flat water on the lower halftile that must be cleared expensively? */
3023 bool was_water = (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh_old));
3024
3025 /* Allow clearing the water only if there is no ship */
3026 if (was_water && HasVehicleOnPos(tile, NULL, &EnsureNoShipProc)) return_cmd_error(STR_ERROR_SHIP_IN_THE_WAY);
3027
3028 /* First test autoslope. However if it succeeds we still have to test the rest, because non-autoslope terraforming is cheaper. */
3029 CommandCost autoslope_result = TestAutoslopeOnRailTile(tile, flags, z_old, tileh_old, z_new, tileh_new, rail_bits);
3030
3031 /* When there is only a single horizontal/vertical track, one corner can be terraformed. */
3032 Corner allowed_corner;
3033 switch (rail_bits) {
3034 case TRACK_BIT_RIGHT: allowed_corner = CORNER_W; break;
3035 case TRACK_BIT_UPPER: allowed_corner = CORNER_S; break;
3036 case TRACK_BIT_LEFT: allowed_corner = CORNER_E; break;
3037 case TRACK_BIT_LOWER: allowed_corner = CORNER_N; break;
3038 default: return autoslope_result;
3039 }
3040
3041 Foundation f_old = GetRailFoundation(tileh_old, rail_bits);
3042
3043 /* Do not allow terraforming if allowed_corner is part of anti-zig-zag foundations */
3044 if (tileh_old != SLOPE_NS && tileh_old != SLOPE_EW && IsSpecialRailFoundation(f_old)) return autoslope_result;
3045
3046 /* Everything is valid, which only changes allowed_corner */
3047 for (Corner corner = (Corner)0; corner < CORNER_END; corner = (Corner)(corner + 1)) {
3048 if (allowed_corner == corner) continue;
3049 if (z_old + GetSlopeZInCorner(tileh_old, corner) != z_new + GetSlopeZInCorner(tileh_new, corner)) return autoslope_result;
3050 }
3051
3052 /* Make the ground dirty */
3053 if ((flags & DC_EXEC) != 0) SetRailGroundType(tile, RAIL_GROUND_BARREN);
3054
3055 /* allow terraforming */
3056 return CommandCost(EXPENSES_CONSTRUCTION, was_water ? _price[PR_CLEAR_WATER] : (Money)0);
3057 } else if (_settings_game.construction.build_on_slopes && AutoslopeEnabled() &&
3058 AutoslopeCheckForEntranceEdge(tile, z_new, tileh_new, GetRailDepotDirection(tile))) {
3059 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_FOUNDATION]);
3060 }
3061 return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
3062 }
3063
3064
3065 extern const TileTypeProcs _tile_type_rail_procs = {
3066 DrawTile_Track, // draw_tile_proc
3067 GetSlopePixelZ_Track, // get_slope_z_proc
3068 ClearTile_Track, // clear_tile_proc
3069 NULL, // add_accepted_cargo_proc
3070 GetTileDesc_Track, // get_tile_desc_proc
3071 GetTileTrackStatus_Track, // get_tile_track_status_proc
3072 ClickTile_Track, // click_tile_proc
3073 NULL, // animate_tile_proc
3074 TileLoop_Track, // tile_loop_proc
3075 ChangeTileOwner_Track, // change_tile_owner_proc
3076 NULL, // add_produced_cargo_proc
3077 VehicleEnter_Track, // vehicle_enter_tile_proc
3078 GetFoundation_Track, // get_foundation_proc
3079 TerraformTile_Track, // terraform_tile_proc
3080 };