#include <msp/time/utils.h>
#include "control.h"
#include "except.h"
+#include "route.h"
#include "tracktype.h"
#include "trafficmanager.h"
#include "train.h"
Train::Train(TrafficManager &tm, Locomotive &l):
trfc_mgr(tm),
loco(l),
+ pending_block(0),
target_speed(0),
+ route(0),
status("Unplaced"),
travel_dist(0),
travel_speed(0),
const map<unsigned, Turnout *> &turnouts = trfc_mgr.get_control().get_turnouts();
for(map<unsigned, Turnout *>::const_iterator i=turnouts.begin(); i!=turnouts.end(); ++i)
{
- i->second->signal_route_changing.connect(sigc::bind(sigc::mem_fun(this, &Train::turnout_route_changing), i->second));
- i->second->signal_route_changed.connect(sigc::bind(sigc::mem_fun(this, &Train::turnout_route_changed), i->second));
+ i->second->signal_path_changing.connect(sigc::bind(sigc::mem_fun(this, &Train::turnout_path_changing), i->second));
+ i->second->signal_path_changed.connect(sigc::bind(sigc::mem_fun(this, &Train::turnout_path_changed), i->second));
}
}
if(!target_speed)
{
trfc_mgr.get_control().set_timer(3*Time::sec).signal_timeout.connect(
- sigc::bind_return(sigc::mem_fun(this, &Train::release_reserved_blocks), false));
+ sigc::bind_return(sigc::bind(sigc::mem_fun(this, &Train::release_blocks), sigc::ref(rsv_blocks)), false));
}
else
reserve_more();
loco.set_reverse(rev);
}
-void Train::place(Block *block, unsigned entry)
+void Train::set_route(const Route *r)
{
- for(list<BlockRef>::iterator i=rsv_blocks.begin(); i!=rsv_blocks.end();)
- {
- i->block->reserve(0);
- i = rsv_blocks.erase(i);
- }
+ route = r;
+ signal_route_changed.emit(route);
+}
- for(list<BlockRef>::iterator i=cur_blocks.begin(); i!=cur_blocks.end();)
- {
- i->block->reserve(0);
- i = cur_blocks.erase(i);
- }
+void Train::place(Block &block, unsigned entry)
+{
+ if(target_speed)
+ set_speed(0);
+
+ release_blocks(rsv_blocks);
+ release_blocks(cur_blocks);
- if(!block->reserve(this))
+ if(!block.reserve(this))
{
set_status("Unplaced");
return;
}
- cur_blocks.push_back(BlockRef(block, entry));
- set_position(block->get_endpoints()[entry]);
+ cur_blocks.push_back(BlockRef(&block, entry));
+ set_position(block.get_endpoints()[entry]);
set_status("Stopped");
}
-bool Train::free_block(Block *block)
+bool Train::free_block(Block &block)
{
unsigned nsens = 0;
for(list<BlockRef>::iterator i=rsv_blocks.begin(); i!=rsv_blocks.end(); ++i)
{
- if(i->block==block)
+ if(i->block==&block)
{
if(nsens<1)
return false;
- while(i!=rsv_blocks.end())
- {
- i->block->reserve(0);
- i = rsv_blocks.erase(i);
- }
+ for(list<BlockRef>::iterator j=i; j!=rsv_blocks.end(); ++j)
+ j->block->reserve(0);
+ rsv_blocks.erase(i, rsv_blocks.end());
update_speed();
return true;
}
return false;
}
+int Train::get_entry_to_block(Block &block) const
+{
+ for(list<BlockRef>::const_iterator i=cur_blocks.begin(); i!=cur_blocks.end(); ++i)
+ if(i->block==&block)
+ return i->entry;
+ for(list<BlockRef>::const_iterator i=rsv_blocks.begin(); i!=rsv_blocks.end(); ++i)
+ if(i->block==&block)
+ return i->entry;
+ return -1;
+}
+
void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt)
{
if(try_reserve && t>try_reserve)
- {
reserve_more();
- update_speed();
- }
if(cur_track)
{
- unsigned route = 0;
+ unsigned path = 0;
if(cur_track->get_turnout_id())
- route = trfc_mgr.get_control().get_turnout(cur_track->get_turnout_id()).get_route();
+ path = trfc_mgr.get_control().get_turnout(cur_track->get_turnout_id()).get_path();
offset += get_real_speed(loco.get_speed())*(dt/Time::sec);
- if(offset>cur_track->get_type().get_route_length(route))
+ float path_len = cur_track->get_type().get_path_length(path);
+ if(offset>path_len)
{
- int out = cur_track->traverse(cur_track_ep, route);
- if(out>=0)
+ unsigned out = cur_track->traverse(cur_track_ep, path);
+ Track *next = cur_track->get_link(out);
+
+ bool ok = false;
+ for(list<BlockRef>::const_iterator i=cur_blocks.begin(); (!ok && i!=cur_blocks.end()); ++i)
+ ok = i->block->get_tracks().count(next);
+
+ if(ok)
{
- Track *next = cur_track->get_link(out);
if(next)
cur_track_ep = next->get_endpoint_by_link(*cur_track);
cur_track = next;
offset = 0;
}
else
- cur_track = 0;
+ offset = path_len-0.001;
}
if(cur_track)
- pos = cur_track->get_point(cur_track_ep, route, offset);
+ pos = cur_track->get_point(cur_track_ep, path, offset);
}
}
for(list<BlockRef>::iterator i=cur_blocks.begin(); i!=cur_blocks.end(); ++i)
i->entry = i->block->traverse(i->entry);
reserve_more();
- update_speed();
if(cur_track)
{
- unsigned route = 0;
+ unsigned path = 0;
if(unsigned turnout = cur_track->get_turnout_id())
- route = trfc_mgr.get_control().get_turnout(turnout).get_route();
- cur_track_ep = cur_track->traverse(cur_track_ep, route);
- offset = cur_track->get_type().get_route_length(route)-offset;
+ path = trfc_mgr.get_control().get_turnout(turnout).get_path();
+ cur_track_ep = cur_track->traverse(cur_track_ep, path);
+ offset = cur_track->get_type().get_path_length(path)-offset;
}
}
if(i->block->get_sensor_id()==addr)
set_position(i->block->get_endpoints()[i->entry]);
- if(target_speed)
- {
- reserve_more();
+ if(target_speed && reserve_more()<2)
update_speed();
- }
}
else
{
break;
}
- if(target_speed)
+ if(target_speed && pending_block && addr==pending_block->get_sensor_id())
reserve_more();
}
}
-void Train::turnout_route_changing(unsigned, Turnout *turnout)
+void Train::turnout_path_changing(unsigned, Turnout *turnout)
{
unsigned tid = turnout->get_address();
for(list<BlockRef>::const_iterator i=cur_blocks.begin(); i!=cur_blocks.end(); ++i)
}
}
-void Train::turnout_route_changed(unsigned, Turnout *turnout)
+void Train::turnout_path_changed(unsigned, Turnout *turnout)
{
unsigned tid = turnout->get_address();
for(list<BlockRef>::iterator i=rsv_blocks.begin(); i!=rsv_blocks.end(); ++i)
i = rsv_blocks.erase(i);
}
reserve_more();
- update_speed();
return;
}
+
+ if(pending_block && tid==pending_block->get_turnout_id())
+ reserve_more();
}
unsigned Train::reserve_more()
if(!last)
return 0;
+ pending_block = 0;
+
+ // See how many blocks we already have
unsigned nsens = 0;
for(list<BlockRef>::const_iterator i=rsv_blocks.begin(); i!=rsv_blocks.end(); ++i)
if(i->block->get_sensor_id())
++nsens;
- bool result = false;
- while(nsens<2)
+ bool got_more = false;
+ BlockRef *good = last;
+ unsigned good_sens = nsens;
+ while(good_sens<3)
{
- int exit = last->block->traverse(last->entry);
- if(exit>=0)
+ // Traverse to the next block
+ unsigned exit = last->block->traverse(last->entry);
+ Block *link = last->block->get_link(exit);
+ if(!link)
+ break;
+
+ int entry = link->get_endpoint_by_link(*last->block);
+ if(!link->reserve(this))
{
- Block *link = last->block->get_link(exit);
- if(link && link->reserve(this))
+ // If we found another train going in the same direction as us, we can keep the blocks we got
+ int other_entry = link->get_train()->get_entry_to_block(*link);
+ if(other_entry==entry || link->traverse(entry)==link->traverse(other_entry))
{
- rsv_blocks.push_back(BlockRef(link, link->get_endpoint_by_link(*last->block)));
- last = &rsv_blocks.back();
- if(last->block->get_sensor_id())
- {
- ++nsens;
- result = true;
- }
+ good = last;
+ good_sens = nsens;
}
- else
+ pending_block = link;
+ break;
+ }
+
+ if(link->get_turnout_id())
+ {
+ const Block::Endpoint &ep = link->get_endpoints()[entry];
+ const Endpoint &track_ep = ep.track->get_type().get_endpoints()[ep.track_ep];
+
+ if(track_ep.paths&(track_ep.paths-1))
+ {
+ // We're facing the points - keep the blocks reserved so far
+ good = last;
+ good_sens = nsens;
+ }
+
+ Turnout &turnout = trfc_mgr.get_control().get_turnout(link->get_turnout_id());
+
+ // Figure out what path we'd like to take on the turnout
+ int path = -1;
+ if(route)
+ path = route->get_turnout(link->get_turnout_id());
+ if(path<0)
+ path = turnout.get_path();
+ if(!((track_ep.paths>>path)&1))
+ {
+ for(unsigned i=0; track_ep.paths>>i; ++i)
+ if((track_ep.paths>>i)&1)
+ path = i;
+ }
+
+ if(path!=turnout.get_path())
+ {
+ // The turnout is set to wrong path - switch and wait for it
+ link->reserve(0);
+ pending_block = link;
+ turnout.set_path(path);
break;
+ }
+ }
+
+ rsv_blocks.push_back(BlockRef(link, entry));
+ last = &rsv_blocks.back();
+ if(last->block->get_sensor_id())
+ {
+ ++nsens;
+ got_more = true;
}
- else
- break;
}
- while(last && !last->block->get_sensor_id())
+ // Unreserve blocks that were not good
+ while(!rsv_blocks.empty() && last!=good)
{
last->block->reserve(0);
rsv_blocks.erase(--rsv_blocks.end());
if(!rsv_blocks.empty())
last = &rsv_blocks.back();
- else
- last = 0;
}
+ if(got_more)
+ update_speed();
+
return nsens;
}
{
if(real<=real_speed[0].speed)
return 0;
- if(real>=real_speed[14].speed)
- return 14;
unsigned low = 0;
unsigned high = 0;
- for(high=0; real_speed[high].speed<real; ++high)
- if(real_speed[high].weight)
- low = high;
+ for(unsigned i=0; (!high && i<=14); ++i)
+ if(real_speed[i].weight)
+ {
+ if(real_speed[i].speed<real)
+ low = i;
+ else
+ high = i;
+ }
+ if(!high)
+ {
+ if(!low)
+ return 0;
+ return min(static_cast<unsigned>(low*real/real_speed[low].speed), 14U);
+ }
float f = (real-real_speed[low].speed)/(real_speed[high].speed-real_speed[low].speed);
return static_cast<unsigned>(low*(1-f)+high*f+0.5);
pos = cur_track->get_endpoint_position(cur_track_ep);
}
-void Train::release_reserved_blocks()
+void Train::release_blocks(list<BlockRef> &blocks)
{
- for(list<BlockRef>::iterator i=rsv_blocks.begin(); i!=rsv_blocks.end(); ++i)
+ for(list<BlockRef>::iterator i=blocks.begin(); i!=blocks.end(); ++i)
i->block->reserve(0);
- rsv_blocks.clear();
+ blocks.clear();
}
projects / r2c2.git / blobdiff