X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibr2c2%2Ftimetable.cpp;h=5be3a03ce07c893df50b05ea4b4985d9e22606b9;hb=59bae8acd679127602cf35d22bcd37e316a5a056;hp=bc8ebe6c43012d628b695ff1ba036f5022489c7f;hpb=1ff06c5bc46a677fa389ef86c6b26664368f1653;p=r2c2.git diff --git a/source/libr2c2/timetable.cpp b/source/libr2c2/timetable.cpp index bc8ebe6..5be3a03 100644 --- a/source/libr2c2/timetable.cpp +++ b/source/libr2c2/timetable.cpp @@ -1,17 +1,11 @@ -/* $Id$ - -This file is part of R²C² -Copyright © 2010 Mikkosoft Productions, Mikko Rasa -Distributed under the GPL -*/ - -#include +#include #include #include "block.h" #include "catalogue.h" #include "driver.h" #include "layout.h" #include "timetable.h" +#include "trackcircuit.h" #include "train.h" using namespace std; @@ -20,15 +14,19 @@ using namespace Msp; namespace R2C2 { Timetable::Timetable(Train &t): - train(t), + TrainAI(t), enabled(false), current_row(0), executing(true), pending_block(0), - pending_train(0) + pending_train(0), + arrived(false) { - train.signal_arrived.connect(sigc::mem_fun(this, &Timetable::train_arrived)); - train.get_layout().get_driver().signal_sensor.connect(sigc::mem_fun(this, &Timetable::sensor_event)); + train.signal_advanced.connect(sigc::mem_fun(this, &Timetable::train_advanced)); + train.signal_ai_event.connect(sigc::mem_fun(this, &Timetable::event)); + Layout &layout = train.get_layout(); + layout.signal_sensor_state_changed.connect(sigc::mem_fun(this, &Timetable::sensor_state_changed)); + layout.signal_block_reserved.connect(sigc::mem_fun(this, &Timetable::block_reserved)); } void Timetable::set_enabled(bool e) @@ -58,7 +56,7 @@ void Timetable::append(const Row &row) void Timetable::insert(unsigned i, const Row &row) { if(i>rows.size()) - throw InvalidParameterValue("Insert position out of range"); + throw out_of_range("Timetable::insert"); rows.insert(rows.begin()+i, row); if(i<=current_row) @@ -68,11 +66,11 @@ void Timetable::insert(unsigned i, const Row &row) const Timetable::Row &Timetable::get_row(unsigned i) const { if(i>=rows.size()) - throw InvalidParameterValue("Row index out of range"); + throw out_of_range("Timetable::get_row"); return rows[i]; } -void Timetable::tick(const Time::TimeStamp &t) +void Timetable::tick(const Time::TimeStamp &t, const Time::TimeDelta &) { if(rows.empty() || !enabled) return; @@ -89,36 +87,72 @@ void Timetable::tick(const Time::TimeStamp &t) Row &row = rows[current_row]; switch(row.type) { - case GOTO: - if(!train.go_to(**parse_location(row.get_param(0)).get_tracks().begin())) - set_enabled(false); + case GOTO_SENSOR: + arrived = false; + train.ai_message(Message("set-destination-block", &get_sensor(row.get_param(0)))); + break; + case GOTO_ZONE: + arrived = false; + train.ai_message(Message("set-destination-zone", &get_zone(row.get_param(0)))); + break; + case TRAVEL_TO: + { + Block *block = &get_sensor(row.get_param(0)); + if(block->get_train()!=&train || block->get_sensor().get_state()(0)); - pending_train = &train; + case TRAVEL_PAST: + pending_block = &get_turnout(row.get_param(0)).get_block(); + pending_train = (pending_block->get_train()==&train ? 0 : &train); executing = false; break; case WAIT_TIME: wait_timeout = t+row.get_param(0)*Time::sec; executing = false; break; + case WAIT_UNTIL: + { + unsigned unixtime = t.to_unixtime(); + unsigned mod = row.get_param(1); + unsigned secs = ((mod+row.get_param(0))-(unixtime%mod))%mod; + wait_timeout = t+secs*Time::sec; + executing = false; + } + break; case WAIT_TRAIN: - pending_train = &train.get_layout().get_train(row.get_param(0)); - pending_block = &parse_location(row.get_param(1)); - executing = false; + { + Train *other_train = &train.get_layout().get_train(row.get_param(0)); + Block *block = &get_sensor(row.get_param(1)); + if(block->get_train()!=other_train || block->get_sensor().get_state()(0)/3.6*train.get_layout().get_catalogue().get_scale()); + if(!arrived) + { + float speed = row.get_param(0)/3.6*train.get_layout().get_catalogue().get_scale(); + train.ai_message(Message("set-target-speed", speed)); + } break; case REVERSE: - train.set_control("reverse", !train.get_control("reverse")); + train.ai_message(Message("toggle-reverse")); break; case ROUTE: - if(!train.set_route(&train.get_layout().get_route(row.get_param(0)))) - set_enabled(false); + train.ai_message(Message("set-route", &train.get_layout().get_route(row.get_param(0)))); break; } @@ -133,16 +167,38 @@ void Timetable::save(list &st) const st.push_back(i->save()); } -Block &Timetable::parse_location(const string &loc) +Block &Timetable::get_sensor(unsigned id) { - if(!loc.compare(0, 7, "sensor ")) - return train.get_layout().get_block(lexical_cast(loc.substr(7))|0x1000); - throw Exception("Named blocks are not supported yet"); + return train.get_layout().get_block(id|0x1000); } -void Timetable::sensor_event(unsigned addr, bool state) +Track &Timetable::get_turnout(unsigned id) { - if(pending_block && pending_block->get_train()==pending_train && addr==pending_block->get_sensor_id() && state) + Block &block = train.get_layout().get_block(id|0x2000); + return **block.get_tracks().begin(); +} + +Zone &Timetable::get_zone(const string &name) +{ + string::size_type space = name.rfind(' '); + if(space==string::npos || space==0) + throw invalid_argument("Timetable::get_zone"); + unsigned number = lexical_cast(name.substr(space+1)); + return train.get_layout().get_zone(name.substr(0, space), number); +} + +void Timetable::sensor_state_changed(Sensor &sensor, Sensor::State state) +{ + if(rows.empty() || !enabled) + return; + + Block *block = 0; + if(TrackCircuit *tc = dynamic_cast(&sensor)) + block = &tc->get_block(); + else + return; + + if(block==pending_block && block->get_train()==pending_train && state>=Sensor::MAYBE_ACTIVE) { pending_block = 0; current_row = (current_row+1)%rows.size(); @@ -150,13 +206,48 @@ void Timetable::sensor_event(unsigned addr, bool state) } } -void Timetable::train_arrived() +void Timetable::block_reserved(Block &block, Train *trn) { + if(rows.empty() || !enabled) + return; + + if(&block==pending_block && trn==pending_train) + { + Row &row = rows[current_row]; + if(row.type==TRAVEL_PAST && !pending_train) + { + pending_block = 0; + current_row = (current_row+1)%rows.size(); + executing = true; + } + } +} + +void Timetable::train_advanced(Block &block) +{ + if(rows.empty() || !enabled) + return; + Row &row = rows[current_row]; - if(row.type==ARRIVE) + if(row.type==TRAVEL_PAST && &block==pending_block && pending_train) + pending_train = 0; +} + +void Timetable::event(TrainAI &, const Message &ev) +{ + if(ev.type=="arrived") { - current_row = (current_row+1)%rows.size(); - executing = true; + if(rows.empty() || !enabled) + return; + + Row &row = rows[current_row]; + if(row.type==ARRIVE) + { + current_row = (current_row+1)%rows.size(); + executing = true; + } + else + arrived = true; } } @@ -176,7 +267,7 @@ template const T &Timetable::Row::get_param(unsigned i) const { if(i>=params.size()) - throw InvalidParameterValue("Parameter index out of range"); + throw out_of_range("Timetable::Row::get_param"); return params[i].value(); } @@ -184,14 +275,20 @@ string Timetable::Row::str() const { switch(type) { - case GOTO: + case GOTO_SENSOR: + return format("set route to sensor %d", get_param(0)); + case GOTO_ZONE: return "set route to "+get_param(0); - case TRAVEL: - return "travel to "+get_param(0); + case TRAVEL_TO: + return format("travel to sensor %d", get_param(0)); + case TRAVEL_PAST: + return format("travel past turnout %d", get_param(0)); case WAIT_TIME: return format("wait for %d seconds", get_param(0)); + case WAIT_UNTIL: + return format("wait until %d mod %d seconds", get_param(0), get_param(1)); case WAIT_TRAIN: - return format("wait for train %d at %s", get_param(0), get_param(1)); + return format("wait for train %d at sensor %d", get_param(0), get_param(1)); case ARRIVE: return "travel until arrival"; case SPEED: @@ -209,14 +306,20 @@ DataFile::Statement Timetable::Row::save() const { switch(type) { - case GOTO: - return DataFile::Statement("goto"), get_param(0); - case TRAVEL: - return DataFile::Statement("travel"), get_param(0); + case GOTO_SENSOR: + return DataFile::Statement("goto_sensor"), get_param(0); + case GOTO_ZONE: + return DataFile::Statement("goto_zone"), get_param(0); + case TRAVEL_TO: + return DataFile::Statement("travel_to"), get_param(0); + case TRAVEL_PAST: + return DataFile::Statement("travel_past"), get_param(0); case WAIT_TIME: return DataFile::Statement("wait"), get_param(0); + case WAIT_UNTIL: + return DataFile::Statement("wait_until"), get_param(0), get_param(1); case WAIT_TRAIN: - return DataFile::Statement("wait_train"), get_param(0), get_param(1); + return DataFile::Statement("wait_train"), get_param(0), get_param(1); case ARRIVE: return DataFile::Statement("arrive"); case SPEED: @@ -234,8 +337,10 @@ Timetable::Row Timetable::Row::parse(const string &s) { if(!s.compare(0, 7, "travel ")) { - if(!s.compare(7, 3, "to ")) - return Row(TRAVEL, s.substr(10)); + if(!s.compare(7, 10, "to sensor ")) + return Row(TRAVEL_TO, lexical_cast(s.substr(17))); + else if(!s.compare(7, 13, "past turnout ")) + return Row(TRAVEL_PAST, lexical_cast(s.substr(20))); else if(!s.compare(7, string::npos, "until arrival")) return Row(ARRIVE); } @@ -250,15 +355,36 @@ Timetable::Row Timetable::Row::parse(const string &s) } else if(!s.compare(9, 6, "train ")) { - string::size_type at = s.find(" at ", 15); + string::size_type at = s.find(" at sensor ", 15); if(at!=string::npos) { Row row(WAIT_TRAIN, lexical_cast(s.substr(15, at-15))); - row.params.push_back(s.substr(at+4)); + row.params.push_back(lexical_cast(s.substr(at+11))); return row; } } } + else if(!s.compare(0, 11, "wait until ")) + { + string::size_type mod = s.find(" mod ", 11); + unsigned nondigit = (mod!=string::npos ? mod+5 : 11); + while(nondigit(s.substr(11, mod-11)); + Row row(WAIT_UNTIL, time); + row.params.push_back(lexical_cast(s.substr(mod+5, nondigit-mod-5))); + return row; + } + else + { + unsigned time = lexical_cast(s.substr(11, nondigit-11)); + Row row(WAIT_UNTIL, time); + row.params.push_back(3600); + return row; + } + } else if(!s.compare(0, 10, "set speed ")) { unsigned nondigit = 11; @@ -271,25 +397,37 @@ Timetable::Row Timetable::Row::parse(const string &s) else if(!s.compare(0, 10, "set route ")) { if(!s.compare(10, 3, "to ")) - return Row(GOTO, s.substr(13)); + { + if(!s.compare(13, 7, "sensor ")) + return Row(GOTO_SENSOR, lexical_cast(s.substr(20))); + else + return Row(GOTO_ZONE, s.substr(13)); + } return Row(ROUTE, s.substr(10)); } - throw InvalidParameterValue("Invalid row"); + throw invalid_argument("Timetable::Row::parse"); } Timetable::Loader::Loader(Timetable &tt): DataFile::ObjectLoader(tt) { - add("arrive", &Loader::arrive); - add("goto", &Loader::go_to); - add("route", &Loader::route); - add("speed", &Loader::speed); - add("reverse", &Loader::reverse); - add("travel", &Loader::travel); - add("wait", &Loader::wait); - add("wait_train", &Loader::wait_train); + add("arrive", &Loader::arrive); + add("goto_sensor", &Loader::goto_sensor); + add("goto_zone", &Loader::goto_zone); + add("route", &Loader::route); + add("speed", &Loader::speed); + add("reverse", &Loader::reverse); + add("travel_to", &Loader::travel_to); + add("travel_past", &Loader::travel_past); + add("wait", &Loader::wait); + add("wait_train", &Loader::wait_train); + add("wait_until", &Loader::wait_until); + + // Deprecated alias + add("goto", &Loader::goto_sensor_str); + add("travel", &Loader::travel_to); } void Timetable::Loader::arrive() @@ -297,9 +435,20 @@ void Timetable::Loader::arrive() obj.rows.push_back(Row(ARRIVE)); } -void Timetable::Loader::go_to(const string &t) +void Timetable::Loader::goto_sensor(unsigned s) +{ + obj.rows.push_back(Row(GOTO_SENSOR, s)); +} + +void Timetable::Loader::goto_sensor_str(const string &s) +{ + if(!s.compare(0, 7, "sensor ")) + obj.rows.push_back(Row(GOTO_SENSOR, lexical_cast(s.substr(7)))); +} + +void Timetable::Loader::goto_zone(const string &z) { - obj.rows.push_back(Row(GOTO, t)); + obj.rows.push_back(Row(GOTO_ZONE, z)); } void Timetable::Loader::route(const string &r) @@ -317,9 +466,14 @@ void Timetable::Loader::speed(unsigned s) obj.rows.push_back(Row(SPEED, s)); } -void Timetable::Loader::travel(const string &t) +void Timetable::Loader::travel_to(unsigned s) +{ + obj.rows.push_back(Row(TRAVEL_TO, s)); +} + +void Timetable::Loader::travel_past(unsigned s) { - obj.rows.push_back(Row(TRAVEL, t)); + obj.rows.push_back(Row(TRAVEL_PAST, s)); } void Timetable::Loader::wait(unsigned t) @@ -327,10 +481,17 @@ void Timetable::Loader::wait(unsigned t) obj.rows.push_back(Row(WAIT_TIME, t)); } -void Timetable::Loader::wait_train(unsigned t, const string &b) +void Timetable::Loader::wait_train(unsigned t, unsigned s) { Row row(WAIT_TRAIN, t); - row.params.push_back(b); + row.params.push_back(s); + obj.rows.push_back(row); +} + +void Timetable::Loader::wait_until(unsigned t, unsigned m) +{ + Row row(WAIT_UNTIL, t); + row.params.push_back(m); obj.rows.push_back(row); }