source/libr2c2/train.cpp

   1 #include <algorithm>
   2 #include <cmath>
   3 #include <msp/core/maputils.h>
   4 #include <msp/core/raii.h>
   5 #include <msp/strings/format.h>
   6 #include <msp/time/units.h>
   7 #include <msp/time/utils.h>
   8 #include "aicontrol.h"
   9 #include "catalogue.h"
  10 #include "driver.h"
  11 #include "layout.h"
  12 #include "route.h"
  13 #include "simplecontroller.h"
  14 #include "speedquantizer.h"
  15 #include "timetable.h"
  16 #include "trackiter.h"
  17 #include "tracktype.h"
  18 #include "train.h"
  19 #include "trainrouter.h"
  20 #include "vehicle.h"
  21 #include "vehicletype.h"
  22 #include "zone.h"
  23
  24 using namespace std;
  25 using namespace Msp;
  26
  27 namespace R2C2 {
  28
  29 Train::Train(Layout &l, const VehicleType &t, unsigned a, const string &p):
  30         layout(l),
  31         loco_type(t),
  32         address(a),
  33         protocol(p),
  34         preceding_train(0),
  35         cur_blocks_end(blocks.end()),
  36         pending_block(0),
  37         reserving(false),
  38         advancing(false),
  39         controller(new SimpleController),
  40         active(false),
  41         current_speed_step(0),
  42         speed_changing(false),
  43         reverse(false),
  44         functions(0),
  45         travel_dist(0),
  46         pure_speed(false),
  47         speed_quantizer(0),
  48         accurate_position(false),
  49         overshoot_dist(false)
  50 {
  51         if(!loco_type.is_locomotive())
  52                 throw invalid_argument("Train::Train");
  53
  54         unsigned speed_steps = layout.get_driver().get_protocol_speed_steps(protocol);
  55         if(speed_steps)
  56                 speed_quantizer = new SpeedQuantizer(speed_steps);
  57
  58         vehicles.push_back(new Vehicle(layout, loco_type));
  59
  60         layout.add_train(*this);
  61
  62         layout.get_driver().add_loco(address, protocol, loco_type);
  63         layout.get_driver().signal_loco_speed.connect(sigc::mem_fun(this, &Train::loco_speed_event));
  64         layout.get_driver().signal_loco_function.connect(sigc::mem_fun(this, &Train::loco_func_event));
  65
  66         layout.signal_block_reserved.connect(sigc::mem_fun(this, &Train::block_reserved));
  67         layout.signal_block_state_changed.connect(sigc::mem_fun(this, &Train::block_state_changed));
  68
  69         layout.get_driver().signal_halt.connect(sigc::mem_fun(this, &Train::halt_event));
  70
  71         const set<Track *> &tracks = layout.get_tracks();
  72         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
  73                 if((*i)->get_turnout_id())
  74                         (*i)->signal_path_changed.connect(sigc::hide(sigc::bind(sigc::mem_fun(this, &Train::turnout_path_changed), sigc::ref(**i))));
  75
  76         controller->signal_control_changed.connect(sigc::mem_fun(this, &Train::control_changed));
  77 }
  78
  79 Train::~Train()
  80 {
  81         delete controller;
  82         for(vector<Vehicle *>::iterator i=vehicles.begin(); i!=vehicles.end(); ++i)
  83                 delete *i;
  84         layout.remove_train(*this);
  85 }
  86
  87 void Train::set_name(const string &n)
  88 {
  89         name = n;
  90
  91         signal_name_changed.emit(name);
  92 }
  93
  94 void Train::add_vehicle(const VehicleType &vt)
  95 {
  96         Vehicle *veh = new Vehicle(layout, vt);
  97         vehicles.back()->attach_back(*veh);
  98         vehicles.push_back(veh);
  99 }
 100
 101 void Train::remove_vehicle(unsigned i)
 102 {
 103         if(i>=vehicles.size())
 104                 throw out_of_range("Train::remove_vehicle");
 105         if(i==0)
 106                 throw logic_error("can't remove locomotive");
 107         delete vehicles[i];
 108         vehicles.erase(vehicles.begin()+i);
 109         if(i<vehicles.size())
 110                 vehicles[i-1]->attach_back(*vehicles[i]);
 111 }
 112
 113 unsigned Train::get_n_vehicles() const
 114 {
 115         return vehicles.size();
 116 }
 117
 118 Vehicle &Train::get_vehicle(unsigned i)
 119 {
 120         if(i>=vehicles.size())
 121                 throw out_of_range("Train::get_vehicle");
 122         return *vehicles[i];
 123 }
 124
 125 const Vehicle &Train::get_vehicle(unsigned i) const
 126 {
 127         if(i>=vehicles.size())
 128                 throw out_of_range("Train::get_vehicle");
 129         return *vehicles[i];
 130 }
 131
 132 void Train::set_control(const string &n, float v)
 133 {
 134         controller->set_control(n, v);
 135 }
 136
 137 void Train::set_active(bool a)
 138 {
 139         if(a==active)
 140                 return;
 141         if(!a && controller->get_speed())
 142                 throw logic_error("moving");
 143
 144         active = a;
 145         if(active)
 146         {
 147                 stop_timeout = Time::TimeStamp();
 148                 reserve_more();
 149         }
 150         else
 151                 stop_timeout = Time::now()+2*Time::sec;
 152 }
 153
 154 void Train::set_function(unsigned func, bool state)
 155 {
 156         if(!loco_type.get_functions().count(func))
 157                 throw invalid_argument("Train::set_function");
 158         layout.get_driver().set_loco_function(address, func, state);
 159 }
 160
 161 float Train::get_control(const string &ctrl) const
 162 {
 163         return controller->get_control(ctrl).value;
 164 }
 165
 166 float Train::get_speed() const
 167 {
 168         return controller->get_speed();
 169 }
 170
 171 float Train::get_quantized_speed() const
 172 {
 173         if(speed_quantizer)
 174                 return speed_quantizer->quantize_speed(controller->get_speed());
 175         else
 176                 return controller->get_speed();
 177 }
 178
 179 bool Train::get_function(unsigned func) const
 180 {
 181         return (functions>>func)&1;
 182 }
 183
 184 void Train::add_ai(TrainAI &ai)
 185 {
 186         ais.push_back(&ai);
 187         ai.signal_event.connect(sigc::bind<0>(signal_ai_event, sigc::ref(ai)));
 188 }
 189
 190 void Train::remove_ai(TrainAI &ai)
 191 {
 192         list<TrainAI *>::iterator i = find(ais.begin(), ais.end(), &ai);
 193         if(i!=ais.end())
 194                 ais.erase(i);
 195 }
 196
 197 void Train::ai_message(const TrainAI::Message &msg)
 198 {
 199         for(list<TrainAI *>::iterator i=ais.begin(); i!=ais.end(); ++i)
 200                 (*i)->message(msg);
 201 }
 202
 203 void Train::place(Block &block, unsigned entry)
 204 {
 205         if(controller->get_speed())
 206                 throw logic_error("moving");
 207
 208         release_blocks();
 209
 210         set_active(false);
 211         accurate_position = false;
 212
 213         blocks.push_back(BlockIter(&block, entry));
 214         if(!block.reserve(this))
 215         {
 216                 blocks.pop_back();
 217                 return;
 218         }
 219
 220         if(reverse)
 221         {
 222                 TrackIter track = BlockIter(&block, entry).reverse().track_iter();
 223                 vehicles.front()->place(*track, track.entry(), 0, Vehicle::FRONT_BUFFER);
 224         }
 225         else
 226         {
 227                 const Block::Endpoint &bep = block.get_endpoint(entry);
 228                 vehicles.back()->place(*bep.track, bep.track_ep, 0, Vehicle::BACK_BUFFER);
 229         }
 230 }
 231
 232 void Train::unplace()
 233 {
 234         if(controller->get_speed())
 235                 throw logic_error("moving");
 236
 237         release_blocks();
 238
 239         set_active(false);
 240         accurate_position = false;
 241
 242         for(vector<Vehicle *>::iterator i=vehicles.begin(); i!=vehicles.end(); ++i)
 243                 (*i)->unplace();
 244 }
 245
 246 void Train::stop_at(Block *block)
 247 {
 248         stop_at_block = block;
 249         if(active && !stop_at_block)
 250                 reserve_more();
 251 }
 252
 253 bool Train::free_block(Block &block)
 254 {
 255         if(get_reserved_distance_until(&block, false)<controller->get_braking_distance()*1.3)
 256                 return false;
 257
 258         unsigned nsens = 0;
 259         for(BlockList::iterator i=cur_blocks_end; i!=blocks.end(); ++i)
 260         {
 261                 if(i->block()==&block)
 262                 {
 263                         if(nsens<1)
 264                                 return false;
 265                         release_blocks(i, blocks.end());
 266                         return true;
 267                 }
 268                 else if((*i)->get_sensor_id())
 269                         ++nsens;
 270         }
 271
 272         return false;
 273 }
 274
 275 void Train::free_noncritical_blocks()
 276 {
 277         if(blocks.empty())
 278                 return;
 279
 280         if(controller->get_speed()==0)
 281         {
 282                 release_blocks(cur_blocks_end, blocks.end());
 283                 return;
 284         }
 285
 286         float margin = 10*layout.get_catalogue().get_scale();
 287         float min_dist = controller->get_braking_distance()*1.3+margin;
 288
 289         Vehicle &veh = *(reverse ? vehicles.back() : vehicles.front());
 290
 291         TrackIter track(veh.get_track(), veh.get_entry());
 292         BlockList::iterator block = blocks.begin();
 293         bool in_rsv = false;
 294         while(block!=blocks.end() && !(*block)->has_track(*track))
 295         {
 296                 ++block;
 297                 if(block==cur_blocks_end)
 298                         in_rsv = true;
 299         }
 300
 301         float dist = veh.get_offset();
 302         if(reverse)
 303                 track.reverse();
 304         else
 305                 dist = track->get_type().get_path_length(track->get_active_path())-dist;
 306         dist -= veh.get_type().get_length()/2;
 307
 308         bool nsens = 0;
 309         while(1)
 310         {
 311                 track = track.next();
 312
 313                 if(!(*block)->has_track(*track))
 314                 {
 315                         ++block;
 316                         if(block==cur_blocks_end)
 317                                 in_rsv = true;
 318                         if(block==blocks.end())
 319                                 return;
 320
 321                         if(dist>min_dist && nsens>0)
 322                         {
 323                                 release_blocks(block, blocks.end());
 324                                 return;
 325                         }
 326
 327                         if(in_rsv && (*block)->get_sensor_id())
 328                                 ++nsens;
 329                 }
 330
 331                 dist += track->get_type().get_path_length(track->get_active_path());
 332         }
 333 }
 334
 335 const BlockIter &Train::get_head_block() const
 336 {
 337         if(blocks.empty())
 338                 throw logic_error("no blocks");
 339         return blocks.back();
 340 }
 341
 342 const BlockIter &Train::get_tail_block() const
 343 {
 344         if(blocks.empty())
 345                 throw logic_error("no blocks");
 346         return blocks.front();
 347 }
 348
 349 int Train::get_entry_to_block(const Block &block) const
 350 {
 351         for(BlockList::const_iterator i=blocks.begin(); i!=blocks.end(); ++i)
 352                 if(i->block()==&block)
 353                         return i->entry();
 354         return -1;
 355 }
 356
 357 float Train::get_reserved_distance() const
 358 {
 359         if(blocks.empty())
 360                 return 0;
 361
 362         float margin = 0;
 363         TrackIter next = blocks.back().next().track_iter();
 364         if(next && next->get_type().is_turnout())
 365                 margin = 15*layout.get_catalogue().get_scale();
 366
 367         return max(get_reserved_distance_until(pending_block, false)-margin, 0.0f);
 368 }
 369
 370 void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt)
 371 {
 372         if(!active && stop_timeout && t>=stop_timeout)
 373         {
 374                 release_blocks(cur_blocks_end, blocks.end());
 375                 stop_timeout = Time::TimeStamp();
 376         }
 377
 378         Driver &driver = layout.get_driver();
 379
 380         for(list<TrainAI *>::iterator i=ais.begin(); i!=ais.end(); ++i)
 381                 (*i)->tick(t, dt);
 382         controller->tick(dt);
 383         float speed = controller->get_speed();
 384         bool moving = speed>0;
 385
 386         if(controller->get_reverse()!=reverse)
 387         {
 388                 reverse = controller->get_reverse();
 389                 bool r = reverse;
 390                 if(loco_type.get_swap_direction())
 391                         r = !r;
 392                 driver.set_loco_reverse(address, r);
 393
 394                 release_blocks(cur_blocks_end, blocks.end());
 395                 reverse_blocks(blocks);
 396
 397                 reserve_more();
 398         }
 399
 400         if(speed_quantizer)
 401         {
 402                 unsigned speed_step = speed_quantizer->find_speed_step(speed);
 403                 if(speed_step!=current_speed_step && !speed_changing && !driver.is_halted() && driver.get_power())
 404                 {
 405                         speed_changing = true;
 406                         driver.set_loco_speed(address, speed_step);
 407
 408                         pure_speed = false;
 409                 }
 410
 411                 speed = speed_quantizer->get_speed(current_speed_step);
 412         }
 413
 414         if(moving)
 415         {
 416                 if(!active)
 417                         set_active(true);
 418
 419                 Vehicle &vehicle = *(reverse ? vehicles.back() : vehicles.front());
 420                 Track *track = vehicle.get_track();
 421
 422                 bool ok = false;
 423                 for(BlockList::const_iterator i=blocks.begin(); (!ok && i!=cur_blocks_end); ++i)
 424                         ok = (*i)->has_track(*track);
 425
 426                 float d = speed*(dt/Time::sec);
 427                 if(ok)
 428                 {
 429                         SetFlag setf(advancing);
 430                         vehicle.advance(reverse ? -d : d);
 431                 }
 432                 else if(accurate_position)
 433                 {
 434                         overshoot_dist += d;
 435                         if(overshoot_dist>40*layout.get_catalogue().get_scale())
 436                         {
 437                                 layout.emergency(name+" has not arrived at sensor");
 438                                 accurate_position = false;
 439                         }
 440                 }
 441         }
 442
 443         if(!blocks.empty() && !blocks.front()->get_sensor_id())
 444         {
 445                 float dist = get_reserved_distance_until(&*blocks.front(), true);
 446
 447                 if(dist>10*layout.get_catalogue().get_scale())
 448                 {
 449                         Block &block = *blocks.front();
 450                         blocks.pop_front();
 451                         block.reserve(0);
 452                 }
 453         }
 454 }
 455
 456 void Train::save(list<DataFile::Statement> &st) const
 457 {
 458         st.push_back((DataFile::Statement("name"), name));
 459
 460         for(vector<Vehicle *>::const_iterator i=vehicles.begin(); i!=vehicles.end(); ++i)
 461                 if(i!=vehicles.begin())
 462                         st.push_back((DataFile::Statement("vehicle"), (*i)->get_type().get_article_number()));
 463
 464         if(speed_quantizer)
 465         {
 466                 DataFile::Statement ss("quantized_speed");
 467                 speed_quantizer->save(ss.sub);
 468                 st.push_back(ss);
 469         }
 470
 471         if(!blocks.empty() && cur_blocks_end!=blocks.begin())
 472         {
 473                 BlockList blks(blocks.begin(), BlockList::const_iterator(cur_blocks_end));
 474                 if(reverse)
 475                         reverse_blocks(blks);
 476
 477                 BlockIter prev = blks.front().flip();
 478                 st.push_back((DataFile::Statement("block_hint"), prev->get_id()));
 479
 480                 for(BlockList::const_iterator i=blks.begin(); i!=blks.end(); ++i)
 481                         st.push_back((DataFile::Statement("block"), (*i)->get_id()));
 482         }
 483
 484         // XXX Need more generic way of saving AI state
 485         for(list<TrainAI *>::const_iterator i=ais.begin(); i!=ais.end(); ++i)
 486         {
 487                 if(TrainRouter *router = dynamic_cast<TrainRouter *>(*i))
 488                 {
 489                         DataFile::Statement ss("router");
 490                         router->save(ss.sub);
 491                         st.push_back(ss);
 492                 }
 493                 else if(Timetable *timetable = dynamic_cast<Timetable *>(*i))
 494                 {
 495                         DataFile::Statement ss("timetable");
 496                         timetable->save(ss.sub);
 497                         st.push_back(ss);
 498                 }
 499         }
 500 }
 501
 502 void Train::control_changed(const Controller::Control &ctrl)
 503 {
 504         signal_control_changed.emit(ctrl.name, ctrl.value);
 505 }
 506
 507 void Train::loco_speed_event(unsigned addr, unsigned speed, bool rev)
 508 {
 509         if(addr==address)
 510         {
 511                 current_speed_step = speed;
 512                 bool r = reverse;
 513                 if(loco_type.get_swap_direction())
 514                         r = !r;
 515                 if(rev!=r)
 516                         layout.get_driver().set_loco_reverse(address, r);
 517                 speed_changing = false;
 518                 pure_speed = false;
 519         }
 520 }
 521
 522 void Train::loco_func_event(unsigned addr, unsigned func, bool state)
 523 {
 524         if(addr==address)
 525         {
 526                 if(state)
 527                         functions |= 1<<func;
 528                 else
 529                         functions &= ~(1<<func);
 530
 531                 signal_function_changed.emit(func, state);
 532         }
 533 }
 534
 535 void Train::block_state_changed(Block &block, Block::State state)
 536 {
 537         if(state==Block::MAYBE_ACTIVE)
 538         {
 539                 // Find the first sensor block from our reserved blocks that isn't this sensor
 540                 BlockList::iterator end;
 541                 unsigned result = 0;
 542                 for(end=cur_blocks_end; end!=blocks.end(); ++end)
 543                         if((*end)->get_sensor_id())
 544                         {
 545                                 if(&**end!=&block)
 546                                 {
 547                                         if(result==0)
 548                                                 result = 2;
 549                                         else if(result==1)
 550                                                 break;
 551                                 }
 552                                 else if(result==0)
 553                                         result = 1;
 554                                 else if(result==2)
 555                                         result = 3;
 556                         }
 557
 558                 if(result==1)
 559                 {
 560                         // Compute speed and update related state
 561                         float travel_time_secs = (Time::now()-last_entry_time)/Time::sec;
 562
 563                         if(pure_speed && speed_quantizer && current_speed_step>0 && travel_time_secs>=2)
 564                                 speed_quantizer->learn(current_speed_step, travel_dist/travel_time_secs, travel_time_secs);
 565
 566                         travel_dist = 0;
 567                         for(BlockList::iterator j=cur_blocks_end; j!=end; ++j)
 568                         {
 569                                 travel_dist += (*j)->get_path_length(j->entry());
 570
 571                                 if(&**j==&block && !advancing)
 572                                 {
 573                                         TrackIter track = j->track_iter();
 574                                         if(reverse)
 575                                         {
 576                                                 track = track.flip();
 577                                                 vehicles.back()->place(*track, track.entry(), 0, Vehicle::BACK_AXLE);
 578                                         }
 579                                         else
 580                                                 vehicles.front()->place(*track, track.entry(), 0, Vehicle::FRONT_AXLE);
 581                                 }
 582                         }
 583                         last_entry_time = Time::now();
 584                         pure_speed = true;
 585                         accurate_position = true;
 586                         overshoot_dist = 0;
 587
 588                         // Move blocks up to the next sensor to our current blocks
 589                         for(BlockList::iterator j=cur_blocks_end; j!=end; ++j)
 590                                 signal_advanced.emit(**j);
 591                         cur_blocks_end = end;
 592
 593                         // Try to get more blocks if we're moving
 594                         if(active)
 595                                 reserve_more();
 596                 }
 597                 else if(result==3)
 598                         layout.emergency("Sensor for "+name+" triggered out of order");
 599         }
 600         else if(state==Block::INACTIVE)
 601         {
 602                 const Vehicle &veh = *(reverse ? vehicles.front() : vehicles.back());
 603
 604                 // Find the first sensor in our current blocks that's still active
 605                 BlockList::iterator end = blocks.begin();
 606                 for(BlockList::iterator i=blocks.begin(); i!=cur_blocks_end; ++i)
 607                 {
 608                         if((*i)->has_track(*veh.get_track()))
 609                                 break;
 610                         if((*i)->get_sensor_id())
 611                         {
 612                                 if(layout.get_driver().get_sensor((*i)->get_sensor_id()))
 613                                         break;
 614                                 else
 615                                 {
 616                                         end = i;
 617                                         ++end;
 618                                 }
 619                         }
 620                 }
 621
 622                 if(end!=blocks.begin() && end!=cur_blocks_end)
 623                         // Free blocks up to the last inactive sensor
 624                         release_blocks(blocks.begin(), end);
 625         }
 626 }
 627
 628 void Train::turnout_path_changed(Track &track)
 629 {
 630         for(list<BlockIter>::iterator i=blocks.begin(); i!=blocks.end(); ++i)
 631                 if((*i)->get_turnout_id()==track.get_turnout_id() && !reserving && &**i==pending_block)
 632                         reserve_more();
 633 }
 634
 635 void Train::halt_event(bool h)
 636 {
 637         if(h)
 638                 accurate_position = false;
 639 }
 640
 641 void Train::block_reserved(const Block &block, const Train *train)
 642 {
 643         if(&block==pending_block && !train && !reserving)
 644                 reserve_more();
 645 }
 646
 647 void Train::reserve_more()
 648 {
 649         if(!active || blocks.empty())
 650                 return;
 651
 652         BlockIter start = blocks.back();
 653         if(&*start==stop_at_block)
 654                 return;
 655         else if(&*start==pending_block)
 656         {
 657                 TrackIter track = start.track_iter();
 658                 if(!track.endpoint().has_path(track->get_active_path()))
 659                         return;
 660         }
 661
 662         pending_block = 0;
 663         preceding_train = 0;
 664
 665         // See how many sensor blocks and how much track we already have
 666         unsigned nsens = 0;
 667         float dist = 0;
 668         for(BlockList::const_iterator i=cur_blocks_end; i!=blocks.end(); ++i)
 669         {
 670                 if((*i)->get_sensor_id())
 671                         ++nsens;
 672                 if(nsens>0)
 673                         dist += (*i)->get_path_length(i->entry());
 674         }
 675
 676         float approach_margin = 50*layout.get_catalogue().get_scale();
 677         float min_dist = controller->get_braking_distance()*1.3+approach_margin*2;
 678
 679         BlockIter block = start;
 680
 681         SetFlag setf(reserving);
 682
 683         while(1)
 684         {
 685                 BlockIter last = block;
 686                 block = block.next();
 687                 if(!block || block->get_endpoints().size()<2)
 688                         // The track ends here
 689                         break;
 690
 691                 if(block->get_turnout_id() && !last->get_turnout_id())
 692                 {
 693                         /* We are arriving at a turnout.  See if we have enough blocks and
 694                         distance reserved. */
 695                         if(nsens>=3 && dist>=min_dist)
 696                                 break;
 697                 }
 698
 699                 blocks.push_back(block);
 700                 if(!block->reserve(this))
 701                 {
 702                         blocks.pop_back();
 703                         pending_block = &*block;
 704                         break;
 705                 }
 706
 707                 if(cur_blocks_end==blocks.end())
 708                         --cur_blocks_end;
 709
 710                 TrackIter track = block.track_iter();
 711                 if(track->is_path_changing())
 712                 {
 713                         pending_block = &*block;
 714                         break;
 715                 }
 716                 else
 717                 {
 718                         const TrackType::Endpoint &entry_ep = track.endpoint();
 719                         unsigned path = track->get_active_path();
 720                         if(!entry_ep.has_path(path))
 721                         {
 722                                 const TrackType::Endpoint &exit_ep = track.reverse().endpoint();
 723                                 if(entry_ep.has_common_paths(exit_ep))
 724                                 {
 725                                         unsigned mask = entry_ep.paths&exit_ep.paths;
 726                                         for(path=0; mask>1; ++path, mask>>=1) ;
 727
 728                                         track->set_active_path(path);
 729                                         if(track->is_path_changing())
 730                                         {
 731                                                 pending_block = &*block;
 732                                                 break;
 733                                         }
 734                                 }
 735                                 else
 736                                         // XXX Do something here
 737                                         break;
 738                         }
 739                 }
 740
 741                 if(&*block==stop_at_block)
 742                         break;
 743
 744                 if(block->get_sensor_id())
 745                         ++nsens;
 746                 if(nsens>0)
 747                         dist += block->get_path_length(block.entry());
 748         }
 749
 750         // Make any sensorless blocks at the beginning immediately current
 751         while(cur_blocks_end!=blocks.end() && !(*cur_blocks_end)->get_sensor_id())
 752                 ++cur_blocks_end;
 753 }
 754
 755 float Train::get_reserved_distance_until(const Block *until_block, bool back) const
 756 {
 757         if(blocks.empty())
 758                 return 0;
 759
 760         Vehicle &veh = *(reverse!=back ? vehicles.back() : vehicles.front());
 761         const VehicleType &vtype = veh.get_type();
 762
 763         TrackIter track(veh.get_track(), veh.get_entry());
 764         if(!track)  // XXX Probably unnecessary
 765                 return 0;
 766
 767         BlockList::const_iterator block = blocks.begin();
 768         while(block!=blocks.end() && !(*block)->has_track(*track))
 769                 ++block;
 770         if(block==blocks.end() || &**block==until_block)
 771                 return 0;
 772
 773         float result = veh.get_offset();
 774         if(reverse!=back)
 775                 track = track.reverse();
 776         else
 777                 result = track->get_type().get_path_length(track->get_active_path())-result;
 778         result -= vtype.get_length()/2;
 779
 780         while(1)
 781         {
 782                 track = track.next();
 783                 if(!track)
 784                         break;
 785
 786                 if(!(*block)->has_track(*track))
 787                 {
 788                         if(back)
 789                         {
 790                                 if(block==blocks.begin())
 791                                         break;
 792                                 --block;
 793                         }
 794                         else
 795                         {
 796                                 ++block;
 797                                 if(block==blocks.end())
 798                                         break;
 799                         }
 800
 801                         if(&**block==until_block)
 802                                 break;
 803                 }
 804
 805                 result += track->get_type().get_path_length(track->get_active_path());
 806         }
 807
 808         return result;
 809 }
 810
 811 void Train::release_blocks()
 812 {
 813         release_blocks(blocks.begin(), blocks.end());
 814 }
 815
 816 void Train::release_blocks(BlockList::iterator begin, BlockList::iterator end)
 817 {
 818         while(begin!=end)
 819         {
 820                 if(begin==cur_blocks_end)
 821                         cur_blocks_end = end;
 822
 823                 Block &block = **begin;
 824                 blocks.erase(begin++);
 825                 block.reserve(0);
 826         }
 827 }
 828
 829 void Train::reverse_blocks(BlockList &blks) const
 830 {
 831         blks.reverse();
 832         for(BlockList::iterator i=blks.begin(); i!=blks.end(); ++i)
 833                 *i = i->reverse();
 834 }
 835
 836
 837 Train::Loader::Loader(Train &t):
 838         DataFile::ObjectLoader<Train>(t),
 839         prev_block(0),
 840         blocks_valid(true)
 841 {
 842         add("block",       &Loader::block);
 843         add("block_hint",  &Loader::block_hint);
 844         add("name",        &Loader::name);
 845         add("quantized_speed",  &Loader::quantized_speed);
 846         add("router",      &Loader::router);
 847         add("timetable",   &Loader::timetable);
 848         add("vehicle",     &Loader::vehicle);
 849 }
 850
 851 void Train::Loader::finish()
 852 {
 853         if(!obj.blocks.empty())
 854         {
 855                 TrackIter track = obj.blocks.front().track_iter();
 856                 float offset = 2*obj.layout.get_catalogue().get_scale();
 857                 obj.vehicles.back()->place(*track, track.entry(), offset, Vehicle::BACK_BUFFER);
 858         }
 859 }
 860
 861 void Train::Loader::block(unsigned id)
 862 {
 863         if(!blocks_valid)
 864                 return;
 865
 866         Block *blk;
 867         try
 868         {
 869                 blk = &obj.layout.get_block(id);
 870         }
 871         catch(const key_error &)
 872         {
 873                 blocks_valid = false;
 874                 return;
 875         }
 876
 877         int entry = -1;
 878         if(prev_block)
 879                 entry = blk->get_endpoint_by_link(*prev_block);
 880         if(entry<0)
 881                 entry = 0;
 882
 883         obj.blocks.push_back(BlockIter(blk, entry));
 884         blk->reserve(&obj);
 885
 886         if(blk->get_sensor_id())
 887                 obj.layout.get_driver().set_sensor(blk->get_sensor_id(), true);
 888
 889         prev_block = blk;
 890 }
 891
 892 void Train::Loader::block_hint(unsigned id)
 893 {
 894         try
 895         {
 896                 prev_block = &obj.layout.get_block(id);
 897         }
 898         catch(const key_error &)
 899         {
 900                 blocks_valid = false;
 901         }
 902 }
 903
 904 void Train::Loader::name(const string &n)
 905 {
 906         obj.set_name(n);
 907 }
 908
 909 void Train::Loader::quantized_speed()
 910 {
 911         if(obj.speed_quantizer)
 912                 load_sub(*obj.speed_quantizer);
 913 }
 914
 915 void Train::Loader::router()
 916 {
 917         TrainRouter *rtr = new TrainRouter(obj);
 918         load_sub(*rtr);
 919 }
 920
 921 void Train::Loader::timetable()
 922 {
 923         Timetable *ttbl = new Timetable(obj);
 924         load_sub(*ttbl);
 925 }
 926
 927 void Train::Loader::vehicle(ArticleNumber art_nr)
 928 {
 929         const VehicleType &vtype = obj.layout.get_catalogue().get_vehicle(art_nr);
 930         Vehicle *veh = new Vehicle(obj.layout, vtype);
 931         obj.vehicles.back()->attach_back(*veh);
 932         obj.vehicles.push_back(veh);
 933 }
 934
 935 } // namespace R2C2