+ else if(route && route->get_tracks().count(entry_ep.track))
+ cur_route = route;
+
+ if(link->get_endpoints().size()<2)
+ {
+ if(!blocking_train)
+ {
+ good = last;
+ good_sens = nsens;
+ good_dist = dist;
+ }
+ break;
+ }
+
+ if(blocking_train)
+ {
+ if(link->get_train()!=blocking_train)
+ {
+ // XXX is it possible that this won't free all the blocks we want?
+ if(blocking_train->free_block(*contested_blocks.back().block))
+ {
+ // Roll back and start actually reserving the blocks
+ last = &rsv_blocks.back();
+ if(blocking_train->get_priority()==priority)
+ blocking_train->yield_to(*this);
+ blocking_train = 0;
+ continue;
+ }
+ else
+ {
+ pending_block = contested_blocks.front().block;
+ break;
+ }
+ }
+ else
+ {
+ contested_blocks.push_back(BlockRef(link, entry));
+ last = &contested_blocks.back();
+ continue;
+ }
+ }
+
+ bool reserved = link->reserve(this);
+ if(!reserved)
+ {
+ /* We've found another train. If it wants to exit the block from the
+ same endpoint we're trying to enter from or the other way around,
+ treat it as coming towards us. Otherwise treat it as going in the
+ same direction. */
+ Train *other_train = link->get_train();
+ int other_entry = other_train->get_entry_to_block(*link);
+ if(other_entry<0)
+ throw LogicError("Block reservation inconsistency");
+
+ int other_prio = other_train->get_priority();
+
+ bool entry_conflict = (static_cast<unsigned>(entry)==link->traverse(other_entry));
+ bool exit_conflict = (link->traverse(entry)==static_cast<unsigned>(other_entry));
+ if(!entry_conflict && !exit_conflict)
+ {
+ /* Same direction, keep the blocks we got so far and wait for the
+ other train to pass */
+ good = last;
+ good_sens = nsens;
+ good_dist = dist;
+
+ // Ask a lesser priority train to free the block for us
+ if(other_train->get_priority()<priority)
+ if(other_train->free_block(*link))
+ reserved = link->reserve(this);
+ }
+ else if(other_prio<priority || (other_prio==priority && other_train!=yielding_to && entry_conflict))
+ {
+ /* A lesser priority train is coming at us, we must ask it to free
+ enough blocks to get clear of it to avoid a potential deadlock */
+ blocking_train = other_train;
+ contested_blocks.clear();
+ contested_blocks.push_back(BlockRef(link, entry));
+ last = &contested_blocks.back();
+ continue;
+ }
+
+ if(!reserved)
+ {
+ pending_block = link;
+ break;
+ }
+ }
+
+ if(link->get_turnout_id())
+ {
+ const Endpoint &track_ep = entry_ep.track->get_type().get_endpoints()[entry_ep.track_ep];
+
+ // Keep the blocks reserved so far, as either us or the other train can diverge
+ good = last;
+ good_sens = nsens;
+ good_dist = dist;
+
+ // Figure out what path we'd like to take on the turnout
+ int path = -1;
+ if(cur_route)
+ path = cur_route->get_turnout(link->get_turnout_id());
+ if(path<0)
+ path = entry_ep.track->get_active_path();
+ if(!((track_ep.paths>>path)&1))
+ {
+ for(unsigned i=0; track_ep.paths>>i; ++i)
+ if((track_ep.paths>>i)&1)
+ path = i;
+ }
+
+ if(path!=static_cast<int>(entry_ep.track->get_active_path()))
+ {
+ // The turnout is set to wrong path - switch and wait for it
+ pending_block = link;
+ entry_ep.track->set_active_path(path);
+ if(pending_block)
+ {
+ link->reserve(0);
+ break;
+ }
+ }
+ }
+
+ if(!contested_blocks.empty() && contested_blocks.front().block==link)
+ contested_blocks.pop_front();
+
+ rsv_blocks.push_back(BlockRef(link, entry));