src/signal.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file signal.cpp functions related to rail signals updating */
   9
  10 #include "stdafx.h"
  11 #include "debug.h"
  12 #include "station_map.h"
  13 #include "tunnelbridge_map.h"
  14 #include "vehicle_func.h"
  15 #include "viewport_func.h"
  16 #include "train.h"
  17 #include "company_base.h"
  18
  19 #include "safeguards.h"
  20
  21
  22 /** these are the maximums used for updating signal blocks */
  23 static const uint SIG_TBU_SIZE    =  64; ///< number of signals entering to block
  24 static const uint SIG_TBD_SIZE    = 256; ///< number of intersections - open nodes in current block
  25 static const uint SIG_GLOB_SIZE   = 128; ///< number of open blocks (block can be opened more times until detected)
  26 static const uint SIG_GLOB_UPDATE =  64; ///< how many items need to be in _globset to force update
  27
  28 static_assert(SIG_GLOB_UPDATE <= SIG_GLOB_SIZE);
  29
  30 /** incidating trackbits with given enterdir */
  31 static const TrackBits _enterdir_to_trackbits[DIAGDIR_END] = {
  32         TRACK_BIT_3WAY_NE,
  33         TRACK_BIT_3WAY_SE,
  34         TRACK_BIT_3WAY_SW,
  35         TRACK_BIT_3WAY_NW
  36 };
  37
  38 /** incidating trackdirbits with given enterdir */
  39 static const TrackdirBits _enterdir_to_trackdirbits[DIAGDIR_END] = {
  40         TRACKDIR_BIT_X_SW | TRACKDIR_BIT_UPPER_W | TRACKDIR_BIT_RIGHT_S,
  41         TRACKDIR_BIT_Y_NW | TRACKDIR_BIT_LOWER_W | TRACKDIR_BIT_RIGHT_N,
  42         TRACKDIR_BIT_X_NE | TRACKDIR_BIT_LOWER_E | TRACKDIR_BIT_LEFT_N,
  43         TRACKDIR_BIT_Y_SE | TRACKDIR_BIT_UPPER_E | TRACKDIR_BIT_LEFT_S
  44 };
  45
  46 /**
  47  * Set containing 'items' items of 'tile and Tdir'
  48  * No tree structure is used because it would cause
  49  * slowdowns in most usual cases
  50  */
  51 template <typename Tdir, uint items>
  52 struct SmallSet {
  53 private:
  54         uint n;           // actual number of units
  55         bool overflowed;  // did we try to overflow the set?
  56         const char *name; // name, used for debugging purposes...
  57
  58         /** Element of set */
  59         struct SSdata {
  60                 TileIndex tile;
  61                 Tdir dir;
  62         } data[items];
  63
  64 public:
  65         /** Constructor - just set default values and 'name' */
  66         SmallSet(const char *name) : n(0), overflowed(false), name(name) { }
  67
  68         /** Reset variables to default values */
  69         void Reset()
  70         {
  71                 this->n = 0;
  72                 this->overflowed = false;
  73         }
  74
  75         /**
  76          * Returns value of 'overflowed'
  77          * @return did we try to overflow the set?
  78          */
  79         bool Overflowed()
  80         {
  81                 return this->overflowed;
  82         }
  83
  84         /**
  85          * Checks for empty set
  86          * @return is the set empty?
  87          */
  88         bool IsEmpty()
  89         {
  90                 return this->n == 0;
  91         }
  92
  93         /**
  94          * Checks for full set
  95          * @return is the set full?
  96          */
  97         bool IsFull()
  98         {
  99                 return this->n == lengthof(data);
 100         }
 101
 102         /**
 103          * Reads the number of items
 104          * @return current number of items
 105          */
 106         uint Items()
 107         {
 108                 return this->n;
 109         }
 110
 111
 112         /**
 113          * Tries to remove first instance of given tile and dir
 114          * @param tile tile
 115          * @param dir and dir to remove
 116          * @return element was found and removed
 117          */
 118         bool Remove(TileIndex tile, Tdir dir)
 119         {
 120                 for (uint i = 0; i < this->n; i++) {
 121                         if (this->data[i].tile == tile && this->data[i].dir == dir) {
 122                                 this->data[i] = this->data[--this->n];
 123                                 return true;
 124                         }
 125                 }
 126
 127                 return false;
 128         }
 129
 130         /**
 131          * Tries to find given tile and dir in the set
 132          * @param tile tile
 133          * @param dir and dir to find
 134          * @return true iff the tile & dir element was found
 135          */
 136         bool IsIn(TileIndex tile, Tdir dir)
 137         {
 138                 for (uint i = 0; i < this->n; i++) {
 139                         if (this->data[i].tile == tile && this->data[i].dir == dir) return true;
 140                 }
 141
 142                 return false;
 143         }
 144
 145         /**
 146          * Adds tile & dir into the set, checks for full set
 147          * Sets the 'overflowed' flag if the set was full
 148          * @param tile tile
 149          * @param dir and dir to add
 150          * @return true iff the item could be added (set wasn't full)
 151          */
 152         bool Add(TileIndex tile, Tdir dir)
 153         {
 154                 if (this->IsFull()) {
 155                         overflowed = true;
 156                         Debug(misc, 0, "SignalSegment too complex. Set {} is full (maximum {})", name, items);
 157                         return false; // set is full
 158                 }
 159
 160                 this->data[this->n].tile = tile;
 161                 this->data[this->n].dir = dir;
 162                 this->n++;
 163
 164                 return true;
 165         }
 166
 167         /**
 168          * Reads the last added element into the set
 169          * @param tile pointer where tile is written to
 170          * @param dir pointer where dir is written to
 171          * @return false iff the set was empty
 172          */
 173         bool Get(TileIndex *tile, Tdir *dir)
 174         {
 175                 if (this->n == 0) return false;
 176
 177                 this->n--;
 178                 *tile = this->data[this->n].tile;
 179                 *dir = this->data[this->n].dir;
 180
 181                 return true;
 182         }
 183 };
 184
 185 static SmallSet<Trackdir, SIG_TBU_SIZE> _tbuset("_tbuset");         ///< set of signals that will be updated
 186 static SmallSet<DiagDirection, SIG_TBD_SIZE> _tbdset("_tbdset");    ///< set of open nodes in current signal block
 187 static SmallSet<DiagDirection, SIG_GLOB_SIZE> _globset("_globset"); ///< set of places to be updated in following runs
 188
 189
 190 /** Check whether there is a train on rail, not in a depot */
 191 static Vehicle *TrainOnTileEnum(Vehicle *v, void *)
 192 {
 193         if (v->type != VEH_TRAIN || Train::From(v)->track == TRACK_BIT_DEPOT) return nullptr;
 194
 195         return v;
 196 }
 197
 198
 199 /**
 200  * Perform some operations before adding data into Todo set
 201  * The new and reverse direction is removed from _globset, because we are sure
 202  * it doesn't need to be checked again
 203  * Also, remove reverse direction from _tbdset
 204  * This is the 'core' part so the graph searching won't enter any tile twice
 205  *
 206  * @param t1 tile we are entering
 207  * @param d1 direction (tile side) we are entering
 208  * @param t2 tile we are leaving
 209  * @param d2 direction (tile side) we are leaving
 210  * @return false iff reverse direction was in Todo set
 211  */
 212 static inline bool CheckAddToTodoSet(TileIndex t1, DiagDirection d1, TileIndex t2, DiagDirection d2)
 213 {
 214         _globset.Remove(t1, d1); // it can be in Global but not in Todo
 215         _globset.Remove(t2, d2); // remove in all cases
 216
 217         assert(!_tbdset.IsIn(t1, d1)); // it really shouldn't be there already
 218
 219         return !_tbdset.Remove(t2, d2);
 220 }
 221
 222
 223 /**
 224  * Perform some operations before adding data into Todo set
 225  * The new and reverse direction is removed from Global set, because we are sure
 226  * it doesn't need to be checked again
 227  * Also, remove reverse direction from Todo set
 228  * This is the 'core' part so the graph searching won't enter any tile twice
 229  *
 230  * @param t1 tile we are entering
 231  * @param d1 direction (tile side) we are entering
 232  * @param t2 tile we are leaving
 233  * @param d2 direction (tile side) we are leaving
 234  * @return false iff the Todo buffer would be overrun
 235  */
 236 static inline bool MaybeAddToTodoSet(TileIndex t1, DiagDirection d1, TileIndex t2, DiagDirection d2)
 237 {
 238         if (!CheckAddToTodoSet(t1, d1, t2, d2)) return true;
 239
 240         return _tbdset.Add(t1, d1);
 241 }
 242
 243
 244 /** Current signal block state flags */
 245 enum SigFlags {
 246         SF_NONE   = 0,
 247         SF_TRAIN  = 1 << 0, ///< train found in segment
 248         SF_EXIT   = 1 << 1, ///< exitsignal found
 249         SF_EXIT2  = 1 << 2, ///< two or more exits found
 250         SF_GREEN  = 1 << 3, ///< green exitsignal found
 251         SF_GREEN2 = 1 << 4, ///< two or more green exits found
 252         SF_FULL   = 1 << 5, ///< some of buffers was full, do not continue
 253         SF_PBS    = 1 << 6, ///< pbs signal found
 254 };
 255
 256 DECLARE_ENUM_AS_BIT_SET(SigFlags)
 257
 258
 259 /**
 260  * Search signal block
 261  *
 262  * @param owner owner whose signals we are updating
 263  * @return SigFlags
 264  */
 265 static SigFlags ExploreSegment(Owner owner)
 266 {
 267         SigFlags flags = SF_NONE;
 268
 269         TileIndex tile = INVALID_TILE; // Stop GCC from complaining about a possibly uninitialized variable (issue #8280).
 270         DiagDirection enterdir = INVALID_DIAGDIR;
 271
 272         while (_tbdset.Get(&tile, &enterdir)) { // tile and enterdir are initialized here, unless I'm mistaken.
 273                 TileIndex oldtile = tile; // tile we are leaving
 274                 DiagDirection exitdir = enterdir == INVALID_DIAGDIR ? INVALID_DIAGDIR : ReverseDiagDir(enterdir); // expected new exit direction (for straight line)
 275
 276                 switch (GetTileType(tile)) {
 277                         case MP_RAILWAY: {
 278                                 if (GetTileOwner(tile) != owner) continue; // do not propagate signals on others' tiles (remove for tracksharing)
 279
 280                                 if (IsRailDepot(tile)) {
 281                                         if (enterdir == INVALID_DIAGDIR) { // from 'inside' - train just entered or left the depot
 282                                                 if (!(flags & SF_TRAIN) && HasVehicleOnPos(tile, nullptr, &TrainOnTileEnum)) flags |= SF_TRAIN;
 283                                                 exitdir = GetRailDepotDirection(tile);
 284                                                 tile += TileOffsByDiagDir(exitdir);
 285                                                 enterdir = ReverseDiagDir(exitdir);
 286                                                 break;
 287                                         } else if (enterdir == GetRailDepotDirection(tile)) { // entered a depot
 288                                                 if (!(flags & SF_TRAIN) && HasVehicleOnPos(tile, nullptr, &TrainOnTileEnum)) flags |= SF_TRAIN;
 289                                                 continue;
 290                                         } else {
 291                                                 continue;
 292                                         }
 293                                 }
 294
 295                                 assert(IsValidDiagDirection(enterdir));
 296                                 TrackBits tracks = GetTrackBits(tile); // trackbits of tile
 297                                 TrackBits tracks_masked = (TrackBits)(tracks & _enterdir_to_trackbits[enterdir]); // only incidating trackbits
 298
 299                                 if (tracks == TRACK_BIT_HORZ || tracks == TRACK_BIT_VERT) { // there is exactly one incidating track, no need to check
 300                                         tracks = tracks_masked;
 301                                         /* If no train detected yet, and there is not no train -> there is a train -> set the flag */
 302                                         if (!(flags & SF_TRAIN) && EnsureNoTrainOnTrackBits(tile, tracks).Failed()) flags |= SF_TRAIN;
 303                                 } else {
 304                                         if (tracks_masked == TRACK_BIT_NONE) continue; // no incidating track
 305                                         if (!(flags & SF_TRAIN) && HasVehicleOnPos(tile, nullptr, &TrainOnTileEnum)) flags |= SF_TRAIN;
 306                                 }
 307
 308                                 if (HasSignals(tile)) { // there is exactly one track - not zero, because there is exit from this tile
 309                                         Track track = TrackBitsToTrack(tracks_masked); // mask TRACK_BIT_X and Y too
 310                                         if (HasSignalOnTrack(tile, track)) { // now check whole track, not trackdir
 311                                                 SignalType sig = GetSignalType(tile, track);
 312                                                 Trackdir trackdir = (Trackdir)FindFirstBit((tracks * 0x101U) & _enterdir_to_trackdirbits[enterdir]);
 313                                                 Trackdir reversedir = ReverseTrackdir(trackdir);
 314                                                 /* add (tile, reversetrackdir) to 'to-be-updated' set when there is
 315                                                  * ANY conventional signal in REVERSE direction
 316                                                  * (if it is a presignal EXIT and it changes, it will be added to 'to-be-done' set later) */
 317                                                 if (HasSignalOnTrackdir(tile, reversedir)) {
 318                                                         if (IsPbsSignal(sig)) {
 319                                                                 flags |= SF_PBS;
 320                                                         } else if (!_tbuset.Add(tile, reversedir)) {
 321                                                                 return flags | SF_FULL;
 322                                                         }
 323                                                 }
 324                                                 if (HasSignalOnTrackdir(tile, trackdir) && !IsOnewaySignal(tile, track)) flags |= SF_PBS;
 325
 326                                                 /* if it is a presignal EXIT in OUR direction and we haven't found 2 green exits yes, do special check */
 327                                                 if (!(flags & SF_GREEN2) && IsPresignalExit(tile, track) && HasSignalOnTrackdir(tile, trackdir)) { // found presignal exit
 328                                                         if (flags & SF_EXIT) flags |= SF_EXIT2; // found two (or more) exits
 329                                                         flags |= SF_EXIT; // found at least one exit - allow for compiler optimizations
 330                                                         if (GetSignalStateByTrackdir(tile, trackdir) == SIGNAL_STATE_GREEN) { // found green presignal exit
 331                                                                 if (flags & SF_GREEN) flags |= SF_GREEN2;
 332                                                                 flags |= SF_GREEN;
 333                                                         }
 334                                                 }
 335
 336                                                 continue;
 337                                         }
 338                                 }
 339
 340                                 for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) { // test all possible exit directions
 341                                         if (dir != enterdir && (tracks & _enterdir_to_trackbits[dir])) { // any track incidating?
 342                                                 TileIndex newtile = tile + TileOffsByDiagDir(dir);  // new tile to check
 343                                                 DiagDirection newdir = ReverseDiagDir(dir); // direction we are entering from
 344                                                 if (!MaybeAddToTodoSet(newtile, newdir, tile, dir)) return flags | SF_FULL;
 345                                         }
 346                                 }
 347
 348                                 continue; // continue the while() loop
 349                                 }
 350
 351                         case MP_STATION:
 352                                 if (!HasStationRail(tile)) continue;
 353                                 if (GetTileOwner(tile) != owner) continue;
 354                                 if (DiagDirToAxis(enterdir) != GetRailStationAxis(tile)) continue; // different axis
 355                                 if (IsStationTileBlocked(tile)) continue; // 'eye-candy' station tile
 356
 357                                 if (!(flags & SF_TRAIN) && HasVehicleOnPos(tile, nullptr, &TrainOnTileEnum)) flags |= SF_TRAIN;
 358                                 tile += TileOffsByDiagDir(exitdir);
 359                                 break;
 360
 361                         case MP_ROAD:
 362                                 if (!IsLevelCrossing(tile)) continue;
 363                                 if (GetTileOwner(tile) != owner) continue;
 364                                 if (DiagDirToAxis(enterdir) == GetCrossingRoadAxis(tile)) continue; // different axis
 365
 366                                 if (!(flags & SF_TRAIN) && HasVehicleOnPos(tile, nullptr, &TrainOnTileEnum)) flags |= SF_TRAIN;
 367                                 tile += TileOffsByDiagDir(exitdir);
 368                                 break;
 369
 370                         case MP_TUNNELBRIDGE: {
 371                                 if (GetTileOwner(tile) != owner) continue;
 372                                 if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) continue;
 373                                 DiagDirection dir = GetTunnelBridgeDirection(tile);
 374
 375                                 if (enterdir == INVALID_DIAGDIR) { // incoming from the wormhole
 376                                         if (!(flags & SF_TRAIN) && HasVehicleOnPos(tile, nullptr, &TrainOnTileEnum)) flags |= SF_TRAIN;
 377                                         enterdir = dir;
 378                                         exitdir = ReverseDiagDir(dir);
 379                                         tile += TileOffsByDiagDir(exitdir); // just skip to next tile
 380                                 } else { // NOT incoming from the wormhole!
 381                                         if (ReverseDiagDir(enterdir) != dir) continue;
 382                                         if (!(flags & SF_TRAIN) && HasVehicleOnPos(tile, nullptr, &TrainOnTileEnum)) flags |= SF_TRAIN;
 383                                         tile = GetOtherTunnelBridgeEnd(tile); // just skip to exit tile
 384                                         enterdir = INVALID_DIAGDIR;
 385                                         exitdir = INVALID_DIAGDIR;
 386                                 }
 387                                 }
 388                                 break;
 389
 390                         default:
 391                                 continue; // continue the while() loop
 392                 }
 393
 394                 if (!MaybeAddToTodoSet(tile, enterdir, oldtile, exitdir)) return flags | SF_FULL;
 395         }
 396
 397         return flags;
 398 }
 399
 400
 401 /**
 402  * Update signals around segment in _tbuset
 403  *
 404  * @param flags info about segment
 405  */
 406 static void UpdateSignalsAroundSegment(SigFlags flags)
 407 {
 408         TileIndex tile = INVALID_TILE; // Stop GCC from complaining about a possibly uninitialized variable (issue #8280).
 409         Trackdir trackdir = INVALID_TRACKDIR;
 410
 411         while (_tbuset.Get(&tile, &trackdir)) {
 412                 assert(HasSignalOnTrackdir(tile, trackdir));
 413
 414                 SignalType sig = GetSignalType(tile, TrackdirToTrack(trackdir));
 415                 SignalState newstate = SIGNAL_STATE_GREEN;
 416
 417                 /* determine whether the new state is red */
 418                 if (flags & SF_TRAIN) {
 419                         /* train in the segment */
 420                         newstate = SIGNAL_STATE_RED;
 421                 } else {
 422                         /* is it a bidir combo? - then do not count its other signal direction as exit */
 423                         if (sig == SIGTYPE_COMBO && HasSignalOnTrackdir(tile, ReverseTrackdir(trackdir))) {
 424                                 /* at least one more exit */
 425                                 if ((flags & SF_EXIT2) &&
 426                                                 /* no green exit */
 427                                                 (!(flags & SF_GREEN) ||
 428                                                 /* only one green exit, and it is this one - so all other exits are red */
 429                                                 (!(flags & SF_GREEN2) && GetSignalStateByTrackdir(tile, ReverseTrackdir(trackdir)) == SIGNAL_STATE_GREEN))) {
 430                                         newstate = SIGNAL_STATE_RED;
 431                                 }
 432                         } else { // entry, at least one exit, no green exit
 433                                 if (IsPresignalEntry(tile, TrackdirToTrack(trackdir)) && (flags & SF_EXIT) && !(flags & SF_GREEN)) newstate = SIGNAL_STATE_RED;
 434                         }
 435                 }
 436
 437                 /* only when the state changes */
 438                 if (newstate != GetSignalStateByTrackdir(tile, trackdir)) {
 439                         if (IsPresignalExit(tile, TrackdirToTrack(trackdir))) {
 440                                 /* for pre-signal exits, add block to the global set */
 441                                 DiagDirection exitdir = TrackdirToExitdir(ReverseTrackdir(trackdir));
 442                                 _globset.Add(tile, exitdir); // do not check for full global set, first update all signals
 443                         }
 444                         SetSignalStateByTrackdir(tile, trackdir, newstate);
 445                         MarkTileDirtyByTile(tile);
 446                 }
 447         }
 448
 449 }
 450
 451
 452 /** Reset all sets after one set overflowed */
 453 static inline void ResetSets()
 454 {
 455         _tbuset.Reset();
 456         _tbdset.Reset();
 457         _globset.Reset();
 458 }
 459
 460
 461 /**
 462  * Updates blocks in _globset buffer
 463  *
 464  * @param owner company whose signals we are updating
 465  * @return state of the first block from _globset
 466  * @pre Company::IsValidID(owner)
 467  */
 468 static SigSegState UpdateSignalsInBuffer(Owner owner)
 469 {
 470         assert(Company::IsValidID(owner));
 471
 472         bool first = true;  // first block?
 473         SigSegState state = SIGSEG_FREE; // value to return
 474
 475         TileIndex tile = INVALID_TILE; // Stop GCC from complaining about a possibly uninitialized variable (issue #8280).
 476         DiagDirection dir = INVALID_DIAGDIR;
 477
 478         while (_globset.Get(&tile, &dir)) {
 479                 assert(_tbuset.IsEmpty());
 480                 assert(_tbdset.IsEmpty());
 481
 482                 /* After updating signal, data stored are always MP_RAILWAY with signals.
 483                  * Other situations happen when data are from outside functions -
 484                  * modification of railbits (including both rail building and removal),
 485                  * train entering/leaving block, train leaving depot...
 486                  */
 487                 switch (GetTileType(tile)) {
 488                         case MP_TUNNELBRIDGE:
 489                                 /* 'optimization assert' - do not try to update signals when it is not needed */
 490                                 assert(GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL);
 491                                 assert(dir == INVALID_DIAGDIR || dir == ReverseDiagDir(GetTunnelBridgeDirection(tile)));
 492                                 _tbdset.Add(tile, INVALID_DIAGDIR);  // we can safely start from wormhole centre
 493                                 _tbdset.Add(GetOtherTunnelBridgeEnd(tile), INVALID_DIAGDIR);
 494                                 break;
 495
 496                         case MP_RAILWAY:
 497                                 if (IsRailDepot(tile)) {
 498                                         /* 'optimization assert' do not try to update signals in other cases */
 499                                         assert(dir == INVALID_DIAGDIR || dir == GetRailDepotDirection(tile));
 500                                         _tbdset.Add(tile, INVALID_DIAGDIR); // start from depot inside
 501                                         break;
 502                                 }
 503                                 [[fallthrough]];
 504
 505                         case MP_STATION:
 506                         case MP_ROAD:
 507                                 if ((TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)) & _enterdir_to_trackbits[dir]) != TRACK_BIT_NONE) {
 508                                         /* only add to set when there is some 'interesting' track */
 509                                         _tbdset.Add(tile, dir);
 510                                         _tbdset.Add(tile + TileOffsByDiagDir(dir), ReverseDiagDir(dir));
 511                                         break;
 512                                 }
 513                                 [[fallthrough]];
 514
 515                         default:
 516                                 /* jump to next tile */
 517                                 tile = tile + TileOffsByDiagDir(dir);
 518                                 dir = ReverseDiagDir(dir);
 519                                 if ((TrackStatusToTrackBits(GetTileTrackStatus(tile, TRANSPORT_RAIL, 0)) & _enterdir_to_trackbits[dir]) != TRACK_BIT_NONE) {
 520                                         _tbdset.Add(tile, dir);
 521                                         break;
 522                                 }
 523                                 /* happens when removing a rail that wasn't connected at one or both sides */
 524                                 continue; // continue the while() loop
 525                 }
 526
 527                 assert(!_tbdset.Overflowed()); // it really shouldn't overflow by these one or two items
 528                 assert(!_tbdset.IsEmpty()); // it wouldn't hurt anyone, but shouldn't happen too
 529
 530                 SigFlags flags = ExploreSegment(owner);
 531
 532                 if (first) {
 533                         first = false;
 534                         /* SIGSEG_FREE is set by default */
 535                         if (flags & SF_PBS) {
 536                                 state = SIGSEG_PBS;
 537                         } else if ((flags & SF_TRAIN) || ((flags & SF_EXIT) && !(flags & SF_GREEN)) || (flags & SF_FULL)) {
 538                                 state = SIGSEG_FULL;
 539                         }
 540                 }
 541
 542                 /* do not do anything when some buffer was full */
 543                 if (flags & SF_FULL) {
 544                         ResetSets(); // free all sets
 545                         break;
 546                 }
 547
 548                 UpdateSignalsAroundSegment(flags);
 549         }
 550
 551         return state;
 552 }
 553
 554
 555 static Owner _last_owner = INVALID_OWNER; ///< last owner whose track was put into _globset
 556
 557
 558 /**
 559  * Update signals in buffer
 560  * Called from 'outside'
 561  */
 562 void UpdateSignalsInBuffer()
 563 {
 564         if (!_globset.IsEmpty()) {
 565                 UpdateSignalsInBuffer(_last_owner);
 566                 _last_owner = INVALID_OWNER; // invalidate
 567         }
 568 }
 569
 570
 571 /**
 572  * Add track to signal update buffer
 573  *
 574  * @param tile tile where we start
 575  * @param track track at which ends we will update signals
 576  * @param owner owner whose signals we will update
 577  */
 578 void AddTrackToSignalBuffer(TileIndex tile, Track track, Owner owner)
 579 {
 580         static const DiagDirection _search_dir_1[] = {
 581                 DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE
 582         };
 583         static const DiagDirection _search_dir_2[] = {
 584                 DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE
 585         };
 586
 587         /* do not allow signal updates for two companies in one run */
 588         assert(_globset.IsEmpty() || owner == _last_owner);
 589
 590         _last_owner = owner;
 591
 592         _globset.Add(tile, _search_dir_1[track]);
 593         _globset.Add(tile, _search_dir_2[track]);
 594
 595         if (_globset.Items() >= SIG_GLOB_UPDATE) {
 596                 /* too many items, force update */
 597                 UpdateSignalsInBuffer(_last_owner);
 598                 _last_owner = INVALID_OWNER;
 599         }
 600 }
 601
 602
 603 /**
 604  * Add side of tile to signal update buffer
 605  *
 606  * @param tile tile where we start
 607  * @param side side of tile
 608  * @param owner owner whose signals we will update
 609  */
 610 void AddSideToSignalBuffer(TileIndex tile, DiagDirection side, Owner owner)
 611 {
 612         /* do not allow signal updates for two companies in one run */
 613         assert(_globset.IsEmpty() || owner == _last_owner);
 614
 615         _last_owner = owner;
 616
 617         _globset.Add(tile, side);
 618
 619         if (_globset.Items() >= SIG_GLOB_UPDATE) {
 620                 /* too many items, force update */
 621                 UpdateSignalsInBuffer(_last_owner);
 622                 _last_owner = INVALID_OWNER;
 623         }
 624 }
 625
 626 /**
 627  * Update signals, starting at one side of a tile
 628  * Will check tile next to this at opposite side too
 629  *
 630  * @see UpdateSignalsInBuffer()
 631  * @param tile tile where we start
 632  * @param side side of tile
 633  * @param owner owner whose signals we will update
 634  * @return the state of the signal segment
 635  */
 636 SigSegState UpdateSignalsOnSegment(TileIndex tile, DiagDirection side, Owner owner)
 637 {
 638         assert(_globset.IsEmpty());
 639         _globset.Add(tile, side);
 640
 641         return UpdateSignalsInBuffer(owner);
 642 }
 643
 644
 645 /**
 646  * Update signals at segments that are at both ends of
 647  * given (existent or non-existent) track
 648  *
 649  * @see UpdateSignalsInBuffer()
 650  * @param tile tile where we start
 651  * @param track track at which ends we will update signals
 652  * @param owner owner whose signals we will update
 653  */
 654 void SetSignalsOnBothDir(TileIndex tile, Track track, Owner owner)
 655 {
 656         assert(_globset.IsEmpty());
 657
 658         AddTrackToSignalBuffer(tile, track, owner);
 659         UpdateSignalsInBuffer(owner);
 660 }