X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibmarklin%2Ftrain.cpp;h=8166c09a86944d1bb4251dec61a38819d08b8920;hb=3d38bcbe8add00b558012fa0cd4e0be26464dbeb;hp=ed57dd7ee143c7f1ec8eb1a5b1081f85d9ad4881;hpb=e39a3bb041867d6b469bb26278ea0b05ebea0277;p=r2c2.git diff --git a/source/libmarklin/train.cpp b/source/libmarklin/train.cpp index ed57dd7..8166c09 100644 --- a/source/libmarklin/train.cpp +++ b/source/libmarklin/train.cpp @@ -13,25 +13,41 @@ Distributed under the GPL #include "catalogue.h" #include "driver.h" #include "layout.h" -#include "locotype.h" #include "route.h" -#include "simplephysics.h" +#include "simplecontroller.h" #include "timetable.h" #include "tracktype.h" #include "train.h" #include "vehicle.h" +#include "vehicletype.h" using namespace std; using namespace Msp; +namespace { + +struct SetFlag +{ + bool &flag; + + SetFlag(bool &f): flag(f) { flag = true; } + ~SetFlag() { flag = false; } +}; + +} + + namespace Marklin { -Train::Train(Layout &l, const LocoType &t, unsigned a): +Train::Train(Layout &l, const VehicleType &t, unsigned a): layout(l), loco_type(t), address(a), + priority(0), pending_block(0), - control(new AIControl(*this, new SimplePhysics)), + reserving(false), + advancing(false), + controller(new AIControl(*this, new SimpleController)), timetable(0), active(false), current_speed(0), @@ -48,6 +64,9 @@ Train::Train(Layout &l, const LocoType &t, unsigned a): accurate_position(false), overshoot_dist(false) { + if(!loco_type.is_locomotive()) + throw InvalidParameterValue("Initial vehicle must be a locomotive"); + vehicles.push_back(new Vehicle(layout, loco_type)); layout.add_train(*this); @@ -60,12 +79,14 @@ Train::Train(Layout &l, const LocoType &t, unsigned a): 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)); - control->signal_control_changed.connect(signal_control_changed); + layout.get_driver().signal_halt.connect(sigc::mem_fun(this, &Train::halt_event)); + + controller->signal_control_changed.connect(sigc::mem_fun(this, &Train::control_changed)); } Train::~Train() { - delete control; + delete controller; delete timetable; for(vector::iterator i=vehicles.begin(); i!=vehicles.end(); ++i) delete *i; @@ -79,6 +100,35 @@ void Train::set_name(const string &n) signal_name_changed.emit(name); } +void Train::set_priority(int p) +{ + priority = p; +} + +void Train::add_vehicle(const VehicleType &vt) +{ + Vehicle *veh = new Vehicle(layout, vt); + vehicles.back()->attach_back(*veh); + vehicles.push_back(veh); +} + +void Train::remove_vehicle(unsigned i) +{ + if(i>=vehicles.size()) + throw InvalidParameterValue("Vehicle index out of range"); + if(i==0) + throw InvalidParameterValue("Can't remove the locomotive"); + delete vehicles[i]; + vehicles.erase(vehicles.begin()+i); + if(iattach_back(*vehicles[i]); +} + +unsigned Train::get_n_vehicles() const +{ + return vehicles.size(); +} + Vehicle &Train::get_vehicle(unsigned i) { if(i>=vehicles.size()) @@ -95,14 +145,14 @@ const Vehicle &Train::get_vehicle(unsigned i) const void Train::set_control(const string &n, float v) { - control->set_control(n, v); + controller->set_control(n, v); } void Train::set_active(bool a) { if(a==active) return; - if(!a && control->get_speed()) + if(!a && controller->get_speed()) throw InvalidState("Can't deactivate while moving"); active = a; @@ -128,11 +178,27 @@ void Train::set_function(unsigned func, bool state) layout.get_driver().set_loco_function(address+1, func-4, state); } +float Train::get_control(const string &ctrl) const +{ + return controller->get_control(ctrl).value; +} + +float Train::get_speed() const +{ + return controller->get_speed(); +} + bool Train::get_function(unsigned func) const { return (functions>>func)&1; } +void Train::set_timetable(Timetable *tt) +{ + delete timetable; + timetable = tt; +} + void Train::set_route(const Route *r) { if(!rsv_blocks.empty()) @@ -149,7 +215,7 @@ void Train::set_route(const Route *r) next_route = 0; end_of_route = false; - if(route) + if(route && !cur_blocks.empty()) { BlockRef &last = (rsv_blocks.empty() ? cur_blocks.back() : rsv_blocks.back()); BlockRef next = last.next(); @@ -161,8 +227,7 @@ void Train::set_route(const Route *r) } } - if(active) - reserve_more(); + reserve_more(); signal_route_changed.emit(route); } @@ -195,7 +260,7 @@ void Train::go_to(const Track &to) void Train::place(Block &block, unsigned entry) { - if(control->get_speed()) + if(controller->get_speed()) throw InvalidState("Must be stopped before placing"); release_blocks(rsv_blocks); @@ -222,7 +287,7 @@ void Train::place(Block &block, unsigned entry) else { const Block::Endpoint &bep = block.get_endpoints()[entry]; - vehicles.front()->place(bep.track, bep.track_ep, 0, Vehicle::BACK_BUFFER); + vehicles.back()->place(bep.track, bep.track_ep, 0, Vehicle::BACK_BUFFER); } } @@ -258,6 +323,9 @@ int Train::get_entry_to_block(Block &block) const float Train::get_reserved_distance() const { + if(cur_blocks.empty()) + return 0; + Vehicle &veh = *(reverse ? vehicles.back() : vehicles.front()); const VehicleType &vtype = veh.get_type(); @@ -316,14 +384,14 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt) if(timetable) timetable->tick(t); - control->tick(dt); - float speed = control->get_speed(); - unsigned speed_notch = find_speed(abs(speed)); + controller->tick(dt); + float speed = controller->get_speed(); + unsigned speed_notch = find_speed(speed); - if(speed && (speed<0)!=reverse) + if(controller->get_reverse()!=reverse) { - driver.set_loco_reverse(address, speed<0); - reverse = speed<0; + reverse = controller->get_reverse(); + driver.set_loco_reverse(address, reverse); release_blocks(rsv_blocks); reverse_blocks(cur_blocks); @@ -357,22 +425,82 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt) float d = get_real_speed(current_speed)*(dt/Time::sec); if(ok) + { + SetFlag setf(advancing); vehicle.advance(reverse ? -d : d); + } else if(accurate_position) { overshoot_dist += d; if(overshoot_dist>40*layout.get_catalogue().get_scale()) + { layout.emergency(name+" has not arrived at sensor"); + accurate_position = false; + } } } - else if(end_of_route) + else if(end_of_route && rsv_blocks.empty()) + { + signal_arrived.emit(); set_route(0); + } + + if(!cur_blocks.empty() && !cur_blocks.front().block->get_sensor_id()) + { + Vehicle &veh = *(reverse ? vehicles.front() : vehicles.back()); + + list::iterator i = cur_blocks.begin(); + const Block::Endpoint &bep = i->block->get_endpoints()[i->entry]; + + Track *track = bep.track; + unsigned entry = bep.track_ep; + + bool found = false; + float dist = veh.get_offset(); + if(reverse) + dist = veh.get_track()->get_type().get_path_length(veh.get_track()->get_active_path())-dist; + dist -= veh.get_type().get_length()/2; + while(1) + { + if(track==veh.get_track()) + { + found = true; + break; + } + + if(i!=cur_blocks.begin()) + { + float path_len = track->get_type().get_path_length(track->get_active_path()); + dist += path_len; + } + + unsigned exit = track->traverse(entry); + Track *next = track->get_link(exit); + entry = next->get_endpoint_by_link(*track); + track = next; + + if(!i->block->get_tracks().count(track)) + { + ++i; + if(i==cur_blocks.end()) + break; + } + } + + if(found && i!=cur_blocks.begin() && dist>10*layout.get_catalogue().get_scale()) + { + cur_blocks.front().block->reserve(0); + cur_blocks.erase(cur_blocks.begin()); + } + } } 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())); @@ -410,6 +538,11 @@ void Train::save(list &st) const } } +void Train::control_changed(const Controller::Control &ctrl) +{ + signal_control_changed.emit(ctrl.name, ctrl.value); +} + void Train::loco_speed_event(unsigned addr, unsigned speed, bool) { if(addr==address) @@ -465,8 +598,11 @@ void Train::sensor_event(unsigned addr, bool state) if(pure_speed) { - RealSpeed &rs = real_speed[current_speed]; - rs.add(travel_dist/travel_time_secs, travel_time_secs); + if(current_speed) + { + RealSpeed &rs = real_speed[current_speed]; + rs.add(travel_dist/travel_time_secs, travel_time_secs); + } set_status(format("Traveling %d kmh", get_travel_speed())); } @@ -477,7 +613,7 @@ void Train::sensor_event(unsigned addr, bool state) j->block->traverse(j->entry, &block_len); travel_dist += block_len; - if(j->block->get_sensor_id()==addr) + if(j->block->get_sensor_id()==addr && !advancing) { const Block::Endpoint &bep = j->block->get_endpoints()[j->entry]; if(reverse) @@ -515,11 +651,7 @@ void Train::sensor_event(unsigned addr, bool state) // Try to get more blocks if we're moving if(active) - { - unsigned nsens = reserve_more(); - if(!nsens && end_of_route) - signal_arrived.emit(); - } + reserve_more(); } else if(result==3) layout.emergency("Sensor for "+name+" triggered out of order"); @@ -534,15 +666,15 @@ void Train::sensor_event(unsigned addr, bool state) if(layout.get_driver().get_sensor(i->block->get_sensor_id())) break; else + { end = i; + ++end; + } } - if(end!=cur_blocks.begin()) - { + if(end!=cur_blocks.begin() && end!=cur_blocks.end()) // Free blocks up to the last inactive sensor - ++end; release_blocks(cur_blocks, cur_blocks.begin(), end); - } } } @@ -553,10 +685,21 @@ void Train::turnout_event(unsigned addr, bool) 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)) - reserve_more(); + { + if(reserving) + pending_block = 0; + else + reserve_more(); + } } } +void Train::halt_event(bool h) +{ + if(h) + accurate_position = false; +} + void Train::block_reserved(const Block &block, const Train *train) { if(&block==pending_block && !train) @@ -565,6 +708,9 @@ void Train::block_reserved(const Block &block, const Train *train) unsigned Train::reserve_more() { + if(!active) + return 0; + BlockRef *last = 0; if(!rsv_blocks.empty()) last = &rsv_blocks.back(); @@ -597,18 +743,13 @@ unsigned Train::reserve_more() } } + SetFlag setf(reserving); + bool got_more = false; BlockRef *good = last; unsigned good_sens = nsens; while(good_sens<3) { - if(last->block->get_endpoints().size()<2) - { - good = last; - good_sens = nsens; - break; - } - // Traverse to the next block unsigned exit = last->block->traverse(last->entry); Block *link = last->block->get_link(exit); @@ -637,19 +778,35 @@ unsigned Train::reserve_more() else if(route && route->get_tracks().count(entry_ep.track)) cur_route = route; - if(!link->reserve(this)) + if(link->get_endpoints().size()<2) + { + good = last; + good_sens = nsens; + break; + } + + bool reserved = link->reserve(this); + if(!reserved) { - // 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(entry)!=link->traverse(other_entry)) + // Ask a lesser priority train to free the block for us + if(link->get_train()->get_priority()get_train()->free_block(*link)) + reserved = link->reserve(this); + + if(!reserved) { - good = last; - good_sens = nsens; + // 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(entry)!=link->traverse(other_entry)) + { + good = last; + good_sens = nsens; + } + pending_block = link; + break; } - pending_block = link; - break; } if(link->get_turnout_id()) @@ -676,10 +833,13 @@ unsigned Train::reserve_more() if(path!=static_cast(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; + if(pending_block) + { + link->reserve(0); + break; + } } } @@ -701,6 +861,7 @@ unsigned Train::reserve_more() last = &rsv_blocks.back(); } + // Make any sensorless blocks at the beginning immediately current list::iterator i; for(i=rsv_blocks.begin(); (i!=rsv_blocks.end() && !i->block->get_sensor_id()); ++i) ; @@ -758,7 +919,12 @@ unsigned Train::find_speed(float real) const if(!high) { if(!low) - return 0; + { + if(real) + return 3; + else + return 0; + } return min(static_cast(low*real/real_speed[low].speed), 14U); } @@ -835,41 +1001,72 @@ void Train::RealSpeed::add(float s, float w) Train::Loader::Loader(Train &t): DataFile::BasicLoader(t), - prev_block(0) + prev_block(0), + blocks_valid(true) { add("block", &Loader::block); add("block_hint", &Loader::block_hint); add("name", &Loader::name); + add("priority", &Train::priority); add("real_speed", &Loader::real_speed); add("route", &Loader::route); add("timetable", &Loader::timetable); add("vehicle", &Loader::vehicle); } +void Train::Loader::finish() +{ + if(!obj.cur_blocks.empty()) + { + const BlockRef &blkref = obj.cur_blocks.front(); + const Block::Endpoint &bep = blkref.block->get_endpoints()[blkref.entry]; + obj.vehicles.back()->place(bep.track, bep.track_ep, 0, Vehicle::BACK_BUFFER); + + obj.set_status("Stopped"); + } +} + void Train::Loader::block(unsigned id) { - Block &blk = obj.layout.get_block(id); + if(!blocks_valid) + return; + + Block *blk; + try + { + blk = &obj.layout.get_block(id); + } + catch(const KeyError &) + { + blocks_valid = false; + return; + } + int entry = -1; if(prev_block) - entry = blk.get_endpoint_by_link(*prev_block); + entry = blk->get_endpoint_by_link(*prev_block); if(entry<0) entry = 0; - blk.reserve(&obj); - obj.cur_blocks.push_back(BlockRef(&blk, entry)); - obj.set_status("Stopped"); - const Block::Endpoint &bep = blk.get_endpoints()[entry]; - obj.vehicles.front()->place(bep.track, bep.track_ep, 0, Vehicle::BACK_BUFFER); + blk->reserve(&obj); + obj.cur_blocks.push_back(BlockRef(blk, entry)); - if(blk.get_sensor_id()) - obj.layout.get_driver().set_sensor(blk.get_sensor_id(), true); + if(blk->get_sensor_id()) + obj.layout.get_driver().set_sensor(blk->get_sensor_id(), true); - prev_block = &blk; + prev_block = blk; } void Train::Loader::block_hint(unsigned id) { - prev_block = &obj.layout.get_block(id); + try + { + prev_block = &obj.layout.get_block(id); + } + catch(const KeyError &) + { + blocks_valid = false; + } } void Train::Loader::name(const string &n)