X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibr2c2%2Ftrain.cpp;h=10227222daac98b38956c14975d0a334ad2cc3ab;hb=dec294d40194a640e7b4bccf20dd1baa4a87038c;hp=ab52ce6ad081bd31eb2b6cd919cc7b9c4e744994;hpb=3e3675f8d86b06cdea7df197dfe8866ffb285aec;p=r2c2.git diff --git a/source/libr2c2/train.cpp b/source/libr2c2/train.cpp index ab52ce6..1022722 100644 --- a/source/libr2c2/train.cpp +++ b/source/libr2c2/train.cpp @@ -15,6 +15,7 @@ #include "trackiter.h" #include "tracktype.h" #include "train.h" +#include "trainrouter.h" #include "vehicle.h" #include "vehicletype.h" #include "zone.h" @@ -42,11 +43,8 @@ Train::Train(Layout &l, const VehicleType &t, unsigned a, const string &p): loco_type(t), address(a), protocol(p), - priority(0), - yielding_to(0), preceding_train(0), cur_blocks_end(blocks.end()), - clear_blocks_end(blocks.end()), pending_block(0), reserving(false), advancing(false), @@ -56,7 +54,6 @@ Train::Train(Layout &l, const VehicleType &t, unsigned a, const string &p): speed_changing(false), reverse(false), functions(0), - end_of_route(false), travel_dist(0), pure_speed(false), speed_quantizer(0), @@ -106,16 +103,6 @@ void Train::set_name(const string &n) signal_name_changed.emit(name); } -void Train::set_priority(int p) -{ - priority = p; -} - -void Train::yield_to(const Train &t) -{ - yielding_to = &t; -} - void Train::add_vehicle(const VehicleType &vt) { Vehicle *veh = new Vehicle(layout, vt); @@ -219,207 +206,12 @@ void Train::remove_ai(TrainAI &ai) ais.erase(i); } -TrainAI *Train::get_tagged_ai(const string &tag) const -{ - for(list::const_iterator i=ais.begin(); i!=ais.end(); ++i) - if((*i)->get_tag()==tag) - return *i; - - return 0; -} - void Train::ai_message(const TrainAI::Message &msg) { for(list::iterator i=ais.begin(); i!=ais.end(); ++i) (*i)->message(msg); } -bool Train::set_route(const Route *r) -{ - free_noncritical_blocks(); - - Route *lead = 0; - if(r && !blocks.empty()) - { - TrackIter first = blocks.front().track_iter(); - TrackIter next = blocks.back().next().track_iter(); - if(!r->has_track(*next)) - { - lead = Route::find(next, *r); - if(!lead) - return false; - create_lead_route(lead, lead); - routes.push_front(lead); - } - else if(!r->has_track(*first)) - lead = create_lead_route(0, r); - } - - routes.clear(); - if(lead) - routes.push_back(lead); - if(r) - routes.push_back(r); - end_of_route = false; - - reserve_more(); - - signal_route_changed.emit(get_route()); - - return true; -} - -bool Train::go_to(Track &to) -{ - for(BlockList::const_iterator i=blocks.begin(); i!=cur_blocks_end; ++i) - if((*i)->has_track(to)) - { - signal_arrived.emit(); - return set_route(0); - } - - free_noncritical_blocks(); - - TrackIter next = blocks.back().next().track_iter(); - - Route *route = Route::find(next, to); - if(!route) - return false; - create_lead_route(route, route); - return set_route(route); -} - -bool Train::go_to(const Zone &to) -{ - set tracks; - for(BlockList::const_iterator i=blocks.begin(); i!=blocks.end(); ++i) - tracks.insert((*i)->get_tracks().begin(), (*i)->get_tracks().end()); - - const Zone::TrackSet &ztracks = to.get_tracks(); - unsigned union_size = 0; - for(Zone::TrackSet::const_iterator i=ztracks.begin(); i!=ztracks.end(); ++i) - union_size += tracks.count(*i); - - if(union_size==tracks.size() || union_size==ztracks.size()) - { - signal_arrived.emit(); - return set_route(0); - } - - free_noncritical_blocks(); - - TrackIter next = blocks.back().next().track_iter(); - - Route *route = Route::find(next, to); - if(!route) - return false; - create_lead_route(route, route); - route->add_tracks(ztracks); - return set_route(route); -} - -bool Train::divert(Track &from) -{ - if(!from.get_turnout_id()) - throw invalid_argument("Train::divert"); - if(routes.empty()) - return false; - - unsigned path = 0; - unsigned entry = 0; - list::iterator route = routes.begin(); - - // Follow our routes to find out where we're entering the turnout - for(TrackLoopIter track = blocks.front().track_iter();;) - { - if(!advance_route(route, *track)) - return false; - - if(&*track==&from) - { - Block &block = track->get_block(); - if(block.get_train()==this && !free_block(block)) - return false; - - int route_path = route->route->get_turnout(from.get_turnout_id()); - - // Check that more than one path is available - unsigned ep_paths = track.endpoint().paths; - if(!(ep_paths&(ep_paths-1))) - return false; - - // Choose some other path - for(int i=0; ep_paths>>i; ++i) - if((ep_paths&(1<route->get_path(*track)); - - if(!track || track.looped()) - return false; - } - - TrackIter track = TrackIter(&from, entry).next(path); - if(!track) - return false; - - set tracks; - for(list::iterator i=routes.begin(); i!=routes.end(); ++i) - tracks.insert(i->route->get_tracks().begin(), i->route->get_tracks().end()); - RefPtr diversion = Route::find(track, tracks); - if(!diversion) - return false; - - diversion->set_name("Diversion"); - diversion->add_track(from); - diversion->set_turnout(from.get_turnout_id(), path); - - if(!is_valid_diversion(*diversion, TrackIter(&from, entry))) - return false; - - // Follow the diversion route until we get back to the original route - list::iterator end = routes.end(); - while(1) - { - for(list::iterator i=route; (end==routes.end() && i!=routes.end()); ++i) - if(i->route->has_track(*track)) - end = i; - - if(end!=routes.end()) - break; - else if(!diversion->has_track(*track)) - throw logic_error("bad diversion"); - - track = track.next(diversion->get_path(*track)); - } - - if(route==end) - // We are rejoining the same route we diverted from, duplicate it - routes.insert(end, *route); - else - { - ++route; - routes.erase(route, end); - } - routes.insert(end, RouteRef(diversion.release(), from.get_turnout_id())); - - return true; -} - -const Route *Train::get_route() const -{ - if(routes.empty()) - return 0; - return routes.front().route; -} - void Train::place(Block &block, unsigned entry) { if(controller->get_speed()) @@ -430,10 +222,13 @@ void Train::place(Block &block, unsigned entry) set_active(false); accurate_position = false; + blocks.push_back(BlockIter(&block, entry)); if(!block.reserve(this)) + { + blocks.pop_back(); return; + } - blocks.push_back(BlockIter(&block, entry)); if(reverse) { TrackIter track = BlockIter(&block, entry).reverse().track_iter(); @@ -460,6 +255,11 @@ void Train::unplace() (*i)->unplace(); } +void Train::stop_at(Block *block) +{ + stop_at_block = block; +} + bool Train::free_block(Block &block) { if(get_reserved_distance_until(&block, false)get_braking_distance()*1.3) @@ -542,6 +342,20 @@ void Train::free_noncritical_blocks() } } +const BlockIter &Train::get_head_block() const +{ + if(blocks.empty()) + throw logic_error("no blocks"); + return blocks.back(); +} + +const BlockIter &Train::get_tail_block() const +{ + if(blocks.empty()) + throw logic_error("no blocks"); + return blocks.front(); +} + int Train::get_entry_to_block(const Block &block) const { for(BlockList::const_iterator i=blocks.begin(); i!=blocks.end(); ++i) @@ -560,7 +374,7 @@ float Train::get_reserved_distance() const if(next && next->get_type().is_turnout()) margin = 15*layout.get_catalogue().get_scale(); - return max(get_reserved_distance_until(0, false)-margin, 0.0f); + return max(get_reserved_distance_until(pending_block, false)-margin, 0.0f); } void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt) @@ -635,12 +449,6 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt) } } } - else if(end_of_route && cur_blocks_end==blocks.end()) - { - set_active(false); - signal_arrived.emit(); - set_route(0); - } if(!blocks.empty() && !blocks.front()->get_sensor_id()) { @@ -648,8 +456,9 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt) if(dist>10*layout.get_catalogue().get_scale()) { - blocks.front()->reserve(0); + Block &block = *blocks.front(); blocks.pop_front(); + block.reserve(0); } } } @@ -658,8 +467,6 @@ void Train::save(list &st) const { st.push_back((DataFile::Statement("name"), name)); - st.push_back((DataFile::Statement("priority"), priority)); - for(vector::const_iterator i=vehicles.begin(); i!=vehicles.end(); ++i) if(i!=vehicles.begin()) st.push_back((DataFile::Statement("vehicle"), (*i)->get_type().get_article_number())); @@ -684,22 +491,22 @@ void Train::save(list &st) const st.push_back((DataFile::Statement("block"), (*i)->get_id())); } - if(!routes.empty()) - { - list::const_iterator i = routes.begin(); - for(; (i!=routes.end() && i->route->is_temporary()); ++i) ; - if(i!=routes.end()) - st.push_back((DataFile::Statement("route"), i->route->get_name())); - } - // XXX Need more generic way of saving AI state for(list::const_iterator i=ais.begin(); i!=ais.end(); ++i) - if(Timetable *timetable = dynamic_cast(*i)) + { + if(TrainRouter *router = dynamic_cast(*i)) + { + DataFile::Statement ss("router"); + router->save(ss.sub); + st.push_back(ss); + } + else if(Timetable *timetable = dynamic_cast(*i)) { DataFile::Statement ss("timetable"); timetable->save(ss.sub); st.push_back(ss); } + } } void Train::control_changed(const Controller::Control &ctrl) @@ -788,20 +595,6 @@ void Train::block_state_changed(Block &block, Block::State state) accurate_position = true; overshoot_dist = 0; - // Check if we've reached the next route - if(routes.size()>1) - { - const Route &route = *(++routes.begin())->route; - for(BlockList::iterator j=cur_blocks_end; j!=end; ++j) - if(route.has_track(*j->track_iter())) - { - routes.pop_front(); - // XXX Exceptions? - signal_route_changed.emit(routes.front().route); - break; - } - } - // Move blocks up to the next sensor to our current blocks for(BlockList::iterator j=cur_blocks_end; j!=end; ++j) signal_advanced.emit(**j); @@ -845,8 +638,8 @@ void Train::block_state_changed(Block &block, Block::State state) void Train::turnout_path_changed(Track &track) { for(list::iterator i=blocks.begin(); i!=blocks.end(); ++i) - if((*i)->get_turnout_id()==track.get_turnout_id() && !reserving) - check_turnout_paths(false); + if((*i)->get_turnout_id()==track.get_turnout_id() && !reserving && &**i==pending_block) + reserve_more(); } void Train::halt_event(bool h) @@ -863,10 +656,18 @@ void Train::block_reserved(const Block &block, const Train *train) void Train::reserve_more() { - if(!active || blocks.empty() || end_of_route) + if(!active || blocks.empty()) return; BlockIter start = blocks.back(); + if(&*start==stop_at_block) + return; + else if(&*start==pending_block) + { + TrackIter track = start.track_iter(); + if(!track.endpoint().has_path(track->get_active_path())) + return; + } pending_block = 0; preceding_train = 0; @@ -882,168 +683,73 @@ void Train::reserve_more() dist += (*i)->get_path_length(i->entry()); } - list::iterator cur_route = routes.begin(); - advance_route(cur_route, *start.track_iter()); - float approach_margin = 50*layout.get_catalogue().get_scale(); float min_dist = controller->get_braking_distance()*1.3+approach_margin*2; BlockIter block = start; - list::iterator good_end = blocks.end(); - Track *divert_track = 0; - bool try_divert = false; - Train *blocking_train = 0; - BlockList contested_blocks; SetFlag setf(reserving); while(1) { BlockIter last = block; - block = block.next(cur_route!=routes.end() ? cur_route->route : 0); + block = block.next(); if(!block || block->get_endpoints().size()<2) - { - if(!blocking_train) - { - good_end = blocks.end(); - end_of_route = true; - } + // The track ends here break; - } - TrackIter track = block.track_iter(); - - if(cur_route!=routes.end()) + if(block->get_turnout_id() && !last->get_turnout_id()) { - if(!advance_route(cur_route, *track)) - { - // Keep the blocks if we arrived at the end of the route - if(!blocking_train) - { - good_end = blocks.end(); - end_of_route = true; - } + /* We are arriving at a turnout. See if we have enough blocks and + distance reserved. */ + if(nsens>=3 && dist>=min_dist) break; - } } - if(block->get_turnout_id() && !last->get_turnout_id()) + blocks.push_back(block); + if(!block->reserve(this)) { - /* 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; + blocks.pop_back(); + pending_block = &*block; + break; } - if(blocking_train) + if(cur_blocks_end==blocks.end()) + --cur_blocks_end; + + TrackIter track = block.track_iter(); + if(track->is_path_changing()) + { + pending_block = &*block; + break; + } + else { - if(block->get_train()!=blocking_train) + const TrackType::Endpoint &entry_ep = track.endpoint(); + unsigned path = track->get_active_path(); + if(!entry_ep.has_path(path)) { - if(blocking_train->free_block(*contested_blocks.back())) + const TrackType::Endpoint &exit_ep = track.reverse().endpoint(); + if(entry_ep.has_common_paths(exit_ep)) { - // Roll back and start actually reserving the blocks - block = blocks.back(); - cur_route = routes.begin(); - advance_route(cur_route, *block.track_iter().track()); - if(blocking_train->get_priority()==priority) - blocking_train->yield_to(*this); - blocking_train = 0; - continue; + unsigned mask = entry_ep.paths&exit_ep.paths; + for(path=0; mask>1; ++path, mask>>=1) ; + + track->set_active_path(path); + if(track->is_path_changing()) + { + pending_block = &*block; + break; + } } else - { - yield_to(*blocking_train); - pending_block = contested_blocks.front().block(); - try_divert = divert_track; + // XXX Do something here break; - } - } - else - { - contested_blocks.push_back(block); - continue; } } - bool reserved = block->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 = block->get_train(); - int other_entry = other_train->get_entry_to_block(*block); - if(other_entry<0) - throw logic_error("block reservation inconsistency"); - - unsigned exit = block.reverse().entry(); - unsigned other_exit = BlockIter(block.block(), other_entry).reverse().entry(); - 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_end = blocks.end(); - - if(static_cast(other_entry)==block.entry()) - preceding_train = other_train; - } - - int other_prio = other_train->get_priority(); - - if(!entry_conflict && !exit_conflict && other_priofree_block(*block)) - reserved = block->reserve(this); - } - else if(other_train!=yielding_to && (other_priois_active())) - // We are blocked, but there's a diversion possibility - try_divert = true; - - if(!reserved) - { - pending_block = &*block; - break; - } - } - - if(block->get_turnout_id()) - { - const TrackType::Endpoint &track_ep = track.endpoint(); - bool multiple_paths = (track_ep.paths&(track_ep.paths-1)); - - 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 */ - divert_track = &*track; - } - - if(!contested_blocks.empty() && contested_blocks.front()==block) - 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==stop_at_block) + break; if(block->get_sensor_id()) ++nsens; @@ -1051,61 +757,9 @@ void Train::reserve_more() dist += block->get_path_length(block.entry()); } - // Unreserve blocks that were not good - release_blocks(good_end, blocks.end()); - - 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!=clear_blocks_end && !(*cur_blocks_end)->get_sensor_id()) + while(cur_blocks_end!=blocks.end() && !(*cur_blocks_end)->get_sensor_id()) ++cur_blocks_end; - - if(try_divert && divert(*divert_track)) - 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; - } - } - - if(i==clear_blocks_end) - ++clear_blocks_end; - } } float Train::get_reserved_distance_until(const Block *until_block, bool back) const @@ -1121,9 +775,9 @@ float Train::get_reserved_distance_until(const Block *until_block, bool back) co return 0; BlockList::const_iterator block = blocks.begin(); - while(block!=clear_blocks_end && !(*block)->has_track(*track)) + while(block!=blocks.end() && !(*block)->has_track(*track)) ++block; - if(block==clear_blocks_end || &**block==until_block) + if(block==blocks.end() || &**block==until_block) return 0; float result = veh.get_offset(); @@ -1150,7 +804,7 @@ float Train::get_reserved_distance_until(const Block *until_block, bool back) co else { ++block; - if(block==clear_blocks_end) + if(block==blocks.end()) break; } @@ -1175,15 +829,10 @@ 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; } } @@ -1194,99 +843,6 @@ void Train::reverse_blocks(BlockList &blks) const *i = i->reverse(); } -bool Train::advance_route(list::iterator &iter, Track &track) -{ - while(iter!=routes.end() && !iter->route->has_track(track)) - ++iter; - if(iter==routes.end()) - return false; - - list::iterator next = iter; - ++next; - if(next!=routes.end() && next->diversion && next->route->has_track(track)) - iter = next; - - return true; -} - -Route *Train::create_lead_route(Route *lead, const Route *target) -{ - if(!lead) - { - lead = new Route(layout); - lead->set_name("Lead"); - lead->set_temporary(true); - } - - set tracks; - for(BlockList::iterator i=blocks.begin(); i!=blocks.end(); ++i) - { - const set &btracks = (*i)->get_tracks(); - for(set::const_iterator j=btracks.begin(); j!=btracks.end(); ++j) - if(!target || !target->has_track(**j)) - tracks.insert(*j); - } - - lead->add_tracks(tracks); - - return lead; -} - -bool Train::is_valid_diversion(const Route &diversion, const TrackIter &from) -{ - float diversion_len = 0; - TrackLoopIter track1 = from; - while(diversion.has_track(*track1)) - { - unsigned path = diversion.get_path(*track1); - diversion_len += track1->get_type().get_path_length(path); - - track1 = track1.next(path); - - if(!track1 || track1.looped()) - return false; - } - - list::iterator route = routes.begin(); - if(!advance_route(route, *from)) - return false; - - float route_len = 0; - TrackLoopIter track2 = from; - while(1) - { - unsigned path = route->route->get_path(*track2); - route_len += track2->get_type().get_path_length(path); - - bool ok = (track2!=from && diversion.has_track(*track2)); - - track2 = track2.next(path); - if(!track2) - return false; - - if(ok) - break; - - if(track2.looped()) - return false; - - if(!advance_route(route, *track2)) - return false; - } - - // Must end up at the same place through both routes - if(track2!=track1) - return false; - - return diversion_len(t), @@ -1296,9 +852,8 @@ Train::Loader::Loader(Train &t): add("block", &Loader::block); add("block_hint", &Loader::block_hint); add("name", &Loader::name); - add("priority", &Train::priority); add("quantized_speed", &Loader::quantized_speed); - add("route", &Loader::route); + add("router", &Loader::router); add("timetable", &Loader::timetable); add("vehicle", &Loader::vehicle); } @@ -1335,8 +890,8 @@ void Train::Loader::block(unsigned id) if(entry<0) entry = 0; - blk->reserve(&obj); obj.blocks.push_back(BlockIter(blk, entry)); + blk->reserve(&obj); if(blk->get_sensor_id()) obj.layout.get_driver().set_sensor(blk->get_sensor_id(), true); @@ -1367,9 +922,10 @@ void Train::Loader::quantized_speed() load_sub(*obj.speed_quantizer); } -void Train::Loader::route(const string &n) +void Train::Loader::router() { - obj.set_route(&obj.layout.get_route(n)); + TrainRouter *rtr = new TrainRouter(obj); + load_sub(*rtr); } void Train::Loader::timetable()