+
+ int entry = link->get_endpoint_by_link(*last->block);
+ if(entry<0)
+ throw LogicError("Block links are inconsistent!");
+
+ const Block::Endpoint &entry_ep = link->get_endpoints()[entry];
+
+ if(cur_route)
+ {
+ if(cur_route!=next_route && next_route && next_route->get_tracks().count(entry_ep.track))
+ cur_route = next_route;
+ else if(!cur_route->get_tracks().count(entry_ep.track))
+ {
+ // Keep the blocks if we arrived at the end of the route
+ good = last;
+ good_sens = nsens;
+ end_of_route = true;
+ break;
+ }
+ }
+ else if(route && route->get_tracks().count(entry_ep.track))
+ cur_route = route;
+
+ if(!link->reserve(this))
+ {
+ // If we found another train and it's not headed straight for us, we can keep the blocks we got
+ int other_entry = link->get_train()->get_entry_to_block(*link);
+ if(other_entry<0)
+ throw LogicError("Block reservation inconsistency");
+ if(static_cast<unsigned>(entry)!=link->traverse(other_entry))
+ {
+ good = last;
+ good_sens = nsens;
+ }
+ 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;
+
+ // 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
+ link->reserve(0);
+ pending_block = link;
+ entry_ep.track->set_active_path(path);
+ break;
+ }
+ }
+
+ rsv_blocks.push_back(BlockRef(link, entry));
+ last = &rsv_blocks.back();
+ if(last->block->get_sensor_id())
+ {
+ ++nsens;
+ got_more = true;
+ }
+ }
+
+ // Unreserve blocks that were not good
+ while(!rsv_blocks.empty() && last!=good)
+ {
+ last->block->reserve(0);
+ rsv_blocks.erase(--rsv_blocks.end());
+ if(!rsv_blocks.empty())
+ last = &rsv_blocks.back();
+ }
+
+ return good_sens;
+}
+
+float Train::get_real_speed(unsigned i) const
+{
+ if(real_speed[i].weight)
+ return real_speed[i].speed;
+
+ unsigned low;
+ unsigned high;
+ for(low=i; low>0; --low)
+ if(real_speed[low].weight)
+ break;
+ for(high=i; high<14; ++high)
+ if(real_speed[high].weight)
+ break;
+
+ if(real_speed[high].weight)
+ {
+ if(real_speed[low].weight)
+ {
+ float f = float(i-low)/(high-low);
+ return real_speed[low].speed*(1-f)+real_speed[high].speed*f;
+ }
+ else
+ return real_speed[high].speed*float(i)/high;
+ }
+ else if(real_speed[low].weight)
+ return real_speed[low].speed*float(i)/low;
+ else
+ return 0;
+}
+
+unsigned Train::find_speed(float real) const
+{
+ if(real<=real_speed[0].speed)
+ return 0;
+
+ unsigned low = 0;
+ unsigned high = 0;
+ for(unsigned i=0; (!high && i<=14); ++i)
+ if(real_speed[i].weight)
+ {
+ if(real_speed[i].speed<real)
+ low = i;
+ else
+ high = i;
+ }
+ if(!high)
+ {
+ if(!low)
+ return 0;
+ return min(static_cast<unsigned>(low*real/real_speed[low].speed), 14U);
+ }
+
+ float f = (real-real_speed[low].speed)/(real_speed[high].speed-real_speed[low].speed);
+ return static_cast<unsigned>(low*(1-f)+high*f+0.5);
+}
+
+float Train::get_travel_speed() const
+{
+ float speed = get_real_speed(current_speed);
+ float scale = layout.get_catalogue().get_scale();
+ return static_cast<int>(round(speed/scale*3.6/5))*5;
+}
+
+void Train::set_status(const string &s)
+{
+ status = s;
+ signal_status_changed.emit(s);
+}
+
+void Train::release_blocks(list<BlockRef> &blocks)
+{
+ release_blocks(blocks, blocks.begin(), blocks.end());
+}
+
+void Train::release_blocks(list<BlockRef> &blocks, list<BlockRef>::iterator begin, list<BlockRef>::iterator end)
+{
+ while(begin!=end)
+ {
+ Block *block = begin->block;
+ blocks.erase(begin++);
+ block->reserve(0);