X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibmarklin%2Ftrain.cpp;h=d9bade7dca338c5f20a53ca2624f53f2d4420298;hb=8e3009751ee81e0e5312cae53ee844bdd9e49628;hp=23c4b52ad30851c9a5567c66900425f5afb6d8bc;hpb=c18c79f72c065933b00c6092d9d5054f9e82b8df;p=r2c2.git diff --git a/source/libmarklin/train.cpp b/source/libmarklin/train.cpp index 23c4b52..d9bade7 100644 --- a/source/libmarklin/train.cpp +++ b/source/libmarklin/train.cpp @@ -47,6 +47,7 @@ Train::Train(Layout &l, const VehicleType &t, unsigned a): priority(0), yielding_to(0), cur_blocks_end(blocks.end()), + clear_blocks_end(blocks.end()), pending_block(0), reserving(false), advancing(false), @@ -78,10 +79,14 @@ Train::Train(Layout &l, const VehicleType &t, unsigned a): layout.signal_block_reserved.connect(sigc::mem_fun(this, &Train::block_reserved)); layout.get_driver().signal_sensor.connect(sigc::mem_fun(this, &Train::sensor_event)); - layout.get_driver().signal_turnout.connect(sigc::mem_fun(this, &Train::turnout_event)); layout.get_driver().signal_halt.connect(sigc::mem_fun(this, &Train::halt_event)); + const set &tracks = layout.get_tracks(); + for(set::const_iterator i=tracks.begin(); i!=tracks.end(); ++i) + if((*i)->get_turnout_id()) + (*i)->signal_path_changed.connect(sigc::hide(sigc::bind(sigc::mem_fun(this, &Train::turnout_path_changed), sigc::ref(**i)))); + controller->signal_control_changed.connect(sigc::mem_fun(this, &Train::control_changed)); } @@ -286,7 +291,7 @@ bool Train::divert(Track &from) int route_path = route->route->get_turnout(from.get_turnout_id()); // Check that more than one path is available - unsigned ep_paths = track->get_type().get_endpoints()[track.entry()].paths; + unsigned ep_paths = track.endpoint().paths; if(!(ep_paths&(ep_paths-1))) return false; @@ -386,7 +391,7 @@ void Train::place(Block &block, unsigned entry) } else { - const Block::Endpoint &bep = block.get_endpoints()[entry]; + const Block::Endpoint &bep = block.get_endpoint(entry); vehicles.back()->place(*bep.track, bep.track_ep, 0, Vehicle::BACK_BUFFER); } } @@ -508,7 +513,6 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt) if(!active && stop_timeout && t>=stop_timeout) { release_blocks(cur_blocks_end, blocks.end()); - end_of_route = false; stop_timeout = Time::TimeStamp(); } @@ -726,9 +730,9 @@ void Train::sensor_event(unsigned addr, bool state) // Check if we've reached the next route if(routes.size()>1) { - const set &rtracks = (++routes.begin())->route->get_tracks(); + const Route &route = *(++routes.begin())->route; for(BlockList::iterator j=cur_blocks_end; j!=end; ++j) - if(rtracks.count((*j)->get_endpoints()[j->entry()].track)) + if(route.has_track(*j->track_iter())) { routes.pop_front(); // XXX Exceptions? @@ -775,20 +779,11 @@ void Train::sensor_event(unsigned addr, bool state) } } -void Train::turnout_event(unsigned addr, bool) +void Train::turnout_path_changed(Track &track) { - if(pending_block && (!pending_block->get_train() || pending_block->get_train()==this)) - { - unsigned pending_addr = pending_block->get_turnout_id(); - bool double_addr = (*pending_block->get_tracks().begin())->get_type().is_double_address(); - if(addr==pending_addr || (double_addr && addr==pending_addr+1)) - { - if(reserving) - pending_block = 0; - else - reserve_more(); - } - } + for(list::iterator i=blocks.begin(); i!=blocks.end(); ++i) + if((*i)->get_turnout_id()==track.get_turnout_id() && !reserving) + check_turnout_paths(false); } void Train::halt_event(bool h) @@ -803,10 +798,10 @@ void Train::block_reserved(const Block &block, const Train *train) reserve_more(); } -unsigned Train::reserve_more() +void Train::reserve_more() { - if(!active || blocks.empty()) - return 0; + if(!active || blocks.empty() || end_of_route) + return; BlockIter start = blocks.back(); @@ -822,9 +817,6 @@ unsigned Train::reserve_more() if(nsens>0) dist += (*i)->get_path_length(i->entry()); } - - if(end_of_route) - return nsens; list::iterator cur_route = routes.begin(); advance_route(cur_route, *start.track_iter()); @@ -833,22 +825,24 @@ unsigned Train::reserve_more() float min_dist = controller->get_braking_distance()*1.3+approach_margin*2; BlockIter block = start; - BlockIter good = start; + list::iterator good_end = blocks.end(); Track *divert_track = 0; bool try_divert = false; - unsigned good_sens = nsens; - float good_dist = dist; Train *blocking_train = 0; BlockList contested_blocks; SetFlag setf(reserving); - while(good_sens<3 || good_distroute : 0); - if(!block) + if(!block || block->get_endpoints().size()<2) + { + if(!blocking_train) + good_end = blocks.end(); break; + } TrackIter track = block.track_iter(); @@ -859,26 +853,21 @@ unsigned Train::reserve_more() // Keep the blocks if we arrived at the end of the route if(!blocking_train) { - good = last; - good_sens = nsens; - good_dist = dist; + good_end = blocks.end(); end_of_route = true; } break; } } - else if(!routes.empty() && routes.front().route->has_track(*track)) - cur_route = routes.begin(); - if(block->get_endpoints().size()<2) + if(block->get_turnout_id() && !last->get_turnout_id()) { - if(!blocking_train) - { - good = last; - good_sens = nsens; - good_dist = dist; - } - break; + /* We can keep the blocks if we arrive at a turnout from a non-turnout + block. Having a turnout block as our last reserved block is not good + as it would limit our diversion possibilities for little benefit. */ + good_end = blocks.end(); + if(nsens>=3 && dist>=min_dist) + break; } if(blocking_train) @@ -928,13 +917,9 @@ unsigned Train::reserve_more() bool entry_conflict = (block.entry()==other_exit); bool exit_conflict = (exit==static_cast(other_entry)); if(!entry_conflict && !last->get_turnout_id()) - { /* The other train is not coming to the blocks we're holding, so we can keep them. */ - good = last; - good_sens = nsens; - good_dist = dist; - } + good_end = blocks.end(); int other_prio = other_train->get_priority(); @@ -967,45 +952,9 @@ unsigned Train::reserve_more() if(block->get_turnout_id()) { - const TrackType::Endpoint &track_ep = track->get_type().get_endpoints()[track.entry()]; + const TrackType::Endpoint &track_ep = track.endpoint(); bool multiple_paths = (track_ep.paths&(track_ep.paths-1)); - if(multiple_paths || !last->get_turnout_id()) - { - /* We can keep the blocks reserved so far if we are facing the - points or if there was no turnout immediately before this one. - With multiple successive turnouts (as is common in crossovers) it's - best to hold at one we can divert from. */ - good = last; - good_sens = nsens; - good_dist = dist; - } - - // Figure out what path we'd like to take on the turnout - int path = -1; - for(list::iterator i=cur_route; (path<0 && i!=routes.end()); ++i) - path = i->route->get_turnout(block->get_turnout_id()); - if(path<0) - path = track->get_active_path(); - if(!(track_ep.paths&(1<>i; ++i) - if(track_ep.paths&(1<(track->get_active_path())) - { - // The turnout is set to wrong path - switch and wait for it - pending_block = &*block; - track->set_active_path(path); - if(pending_block) - { - block->reserve(0); - break; - } - } - if(multiple_paths && cur_route!=routes.end() && cur_route->diversion!=block->get_turnout_id()) /* There's multiple paths to be taken and we are on a route - take note of the diversion possibility */ @@ -1016,8 +965,14 @@ unsigned Train::reserve_more() contested_blocks.pop_front(); blocks.push_back(block); + if(cur_blocks_end==blocks.end()) --cur_blocks_end; + if(clear_blocks_end==blocks.end()) + --clear_blocks_end; + if(good_end==blocks.end()) + --good_end; + if(block->get_sensor_id()) ++nsens; if(nsens>0) @@ -1025,26 +980,60 @@ unsigned Train::reserve_more() } // Unreserve blocks that were not good - while(blocks.end()!=cur_blocks_end && blocks.back()!=good) - { - if(--blocks.end()==cur_blocks_end) - cur_blocks_end = blocks.end(); - blocks.back()->reserve(0); - blocks.pop_back(); - } + release_blocks(good_end, blocks.end()); - if(!blocks.back()!=start) + if(blocks.back()!=start) // We got some new blocks, so no longer need to yield yielding_to = 0; + check_turnout_paths(true); + // Make any sensorless blocks at the beginning immediately current - while(cur_blocks_end!=blocks.end() && !(*cur_blocks_end)->get_sensor_id()) + while(cur_blocks_end!=clear_blocks_end && !(*cur_blocks_end)->get_sensor_id()) ++cur_blocks_end; if(try_divert && divert(*divert_track)) - return reserve_more(); + reserve_more(); +} + +void Train::check_turnout_paths(bool set) +{ + if(clear_blocks_end==blocks.end()) + return; + + for(list::iterator i=clear_blocks_end; i!=blocks.end(); ++i) + { + if((*i)->get_turnout_id()) + { + TrackIter track = i->track_iter(); + const TrackType::Endpoint &track_ep = track.endpoint(); + + unsigned path = 0; + list::iterator j = i; + if(++j!=blocks.end()) + { + TrackIter rev = j->track_iter().flip(); + unsigned mask = rev.endpoint().paths&track_ep.paths; + for(path=0; mask>1; mask>>=1, ++path) ; + } + else + return; + + if(path!=track->get_active_path()) + { + if(set) + track->set_active_path(path); - return good_sens; + /* Check again, in case the driver was able to service the request + instantly */ + if(!set || path!=track->get_active_path()) + continue; + } + } + + if(i==clear_blocks_end) + ++clear_blocks_end; + } } float Train::get_reserved_distance_until(const Block *until_block, bool back) const @@ -1060,9 +1049,9 @@ float Train::get_reserved_distance_until(const Block *until_block, bool back) co return 0; BlockList::const_iterator block = blocks.begin(); - while(block!=blocks.end() && !(*block)->has_track(*track)) + while(block!=clear_blocks_end && !(*block)->has_track(*track)) ++block; - if(block==blocks.end() || &**block==until_block) + if(block==clear_blocks_end || &**block==until_block) return 0; float result = veh.get_offset(); @@ -1089,7 +1078,7 @@ float Train::get_reserved_distance_until(const Block *until_block, bool back) co else { ++block; - if(block==blocks.end()) + if(block==clear_blocks_end) break; } @@ -1190,10 +1179,15 @@ void Train::release_blocks(BlockList::iterator begin, BlockList::iterator end) { if(begin==cur_blocks_end) cur_blocks_end = end; + if(begin==clear_blocks_end) + clear_blocks_end = end; Block &block = **begin; blocks.erase(begin++); block.reserve(0); + + if(begin==blocks.end()) + end_of_route = false; } }