X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;ds=sidebyside;f=source%2Flibmarklin%2Ftrain.cpp;h=859d3daea7988ea7544eb111cb72964613e7a8cd;hb=9b05c573a38639827697fe393d55b7c76f5bde45;hp=23c4b52ad30851c9a5567c66900425f5afb6d8bc;hpb=c18c79f72c065933b00c6092d9d5054f9e82b8df;p=r2c2.git diff --git a/source/libmarklin/train.cpp b/source/libmarklin/train.cpp index 23c4b52..859d3da 100644 --- a/source/libmarklin/train.cpp +++ b/source/libmarklin/train.cpp @@ -40,20 +40,22 @@ struct SetFlag namespace Marklin { -Train::Train(Layout &l, const VehicleType &t, unsigned a): +Train::Train(Layout &l, const VehicleType &t, unsigned a, const string &p): layout(l), loco_type(t), address(a), + protocol(p), priority(0), yielding_to(0), cur_blocks_end(blocks.end()), + clear_blocks_end(blocks.end()), pending_block(0), reserving(false), advancing(false), controller(new AIControl(*this, new SimpleController)), timetable(0), active(false), - current_speed(0), + current_speed_step(0), speed_changing(false), reverse(false), functions(0), @@ -61,7 +63,7 @@ Train::Train(Layout &l, const VehicleType &t, unsigned a): status("Unplaced"), travel_dist(0), pure_speed(false), - real_speed(15), + real_speed(layout.get_driver().get_protocol_speed_steps(protocol)+1), accurate_position(false), overshoot_dist(false) { @@ -72,16 +74,20 @@ Train::Train(Layout &l, const VehicleType &t, unsigned a): layout.add_train(*this); - layout.get_driver().add_loco(address); + layout.get_driver().add_loco(address, protocol); layout.get_driver().signal_loco_speed.connect(sigc::mem_fun(this, &Train::loco_speed_event)); layout.get_driver().signal_loco_function.connect(sigc::mem_fun(this, &Train::loco_func_event)); 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 +292,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 +392,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 +514,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(); } @@ -518,7 +523,7 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt) timetable->tick(t); controller->tick(dt); float speed = controller->get_speed(); - unsigned speed_notch = find_speed(speed); + unsigned speed_step = find_speed_step(speed); if(controller->get_reverse()!=reverse) { @@ -530,14 +535,14 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt) reserve_more(); } - if(speed_notch!=current_speed && !speed_changing && !driver.is_halted() && driver.get_power()) + if(speed_step!=current_speed_step && !speed_changing && !driver.is_halted() && driver.get_power()) { speed_changing = true; - driver.set_loco_speed(address, speed_notch); + driver.set_loco_speed(address, speed_step); pure_speed = false; - if(speed_notch) + if(speed_step) set_status(format("Traveling %d kmh", get_travel_speed())); else set_status("Waiting"); @@ -555,7 +560,11 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt) for(BlockList::const_iterator i=blocks.begin(); (!ok && i!=cur_blocks_end); ++i) ok = (*i)->has_track(*track); - float d = get_real_speed(current_speed)*(dt/Time::sec); + float d; + if(real_speed.size()>1) + d = get_real_speed(current_speed_step)*(dt/Time::sec); + else + d = speed*(dt/Time::sec); if(ok) { SetFlag setf(advancing); @@ -600,7 +609,7 @@ void Train::save(list &st) const if(i!=vehicles.begin()) st.push_back((DataFile::Statement("vehicle"), (*i)->get_type().get_article_number())); - for(unsigned i=0; i<=14; ++i) + for(unsigned i=0; i0) { - RealSpeed &rs = real_speed[current_speed]; + RealSpeed &rs = real_speed[current_speed_step]; rs.add(travel_dist/travel_time_secs, travel_time_secs); } set_status(format("Traveling %d kmh", get_travel_speed())); @@ -726,9 +735,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 +784,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 +803,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 +822,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 +830,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 +858,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 +922,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 +957,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 +970,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 +985,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); + + /* Check again, in case the driver was able to service the request + instantly */ + if(!set || path!=track->get_active_path()) + continue; + } + } - return good_sens; + if(i==clear_blocks_end) + ++clear_blocks_end; + } } float Train::get_reserved_distance_until(const Block *until_block, bool back) const @@ -1060,9 +1054,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 +1083,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; } @@ -1105,6 +1099,8 @@ float Train::get_reserved_distance_until(const Block *until_block, bool back) co float Train::get_real_speed(unsigned i) const { + if(i==0) + return 0; if(real_speed[i].weight) return real_speed[i].speed; @@ -1113,7 +1109,7 @@ float Train::get_real_speed(unsigned i) const for(low=i; low>0; --low) if(real_speed[low].weight) break; - for(high=i; high<14; ++high) + for(high=i; high+1(low*real/real_speed[low].speed), 14U), last+3); + return min(min(static_cast(low*real/real_speed[low].speed), real_speed.size()-1), last+limit); } float f = (real-real_speed[low].speed)/(real_speed[high].speed-real_speed[low].speed); @@ -1168,7 +1167,7 @@ unsigned Train::find_speed(float real) const float Train::get_travel_speed() const { - float speed = get_real_speed(current_speed); + float speed = get_real_speed(current_speed_step); float scale = layout.get_catalogue().get_scale(); return static_cast(round(speed/scale*3.6/5))*5; } @@ -1190,10 +1189,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; } } @@ -1385,6 +1389,8 @@ void Train::Loader::name(const string &n) void Train::Loader::real_speed(unsigned i, float speed, float weight) { + if(i>=obj.real_speed.size()) + return; obj.real_speed[i].speed = speed; obj.real_speed[i].weight = weight; }