BlockAllocator::BlockAllocator(Train &t):
train(t),
+ active(false),
cur_blocks_end(blocks.end()),
next_sensor(0),
pending_block(0),
}
}
-void BlockAllocator::start_from(const BlockIter &block)
+bool BlockAllocator::start_from(const BlockIter &block)
{
if(!block)
throw invalid_argument("BlockAllocator::start_from");
+ float remaining_length = 0;
+ unsigned n_vehs = train.get_n_vehicles();
+ for(unsigned i=0; i<n_vehs; ++i)
+ remaining_length += train.get_vehicle(i).get_type().get_length();
+
clear();
- reserve_block(block);
+
+ BlockList blocks_to_reserve;
+ for(BlockIter b=block; b; b=b.next())
+ {
+ if(b->get_train())
+ break;
+ blocks_to_reserve.push_back(b);
+ for(TrackIter t=b.track_iter(); (t && &t->get_block()==&*b); t=t.next())
+ remaining_length -= t->get_path_length();
+ if(remaining_length<=0)
+ break;
+ }
+
+ if(remaining_length>0)
+ return false;
+
+ for(BlockList::iterator i=blocks_to_reserve.begin(); i!=blocks_to_reserve.end(); ++i)
+ {
+ blocks.push_back(*i);
+ try
+ {
+ (*i)->reserve(&train);
+ }
+ catch(...)
+ {
+ blocks.pop_back();
+ while(i!=blocks_to_reserve.begin())
+ {
+ blocks.pop_back();
+ (*--i)->reserve(0);
+ }
+ throw;
+ }
+ }
+
+ return true;
}
void BlockAllocator::rewind_to(const Block &block)
/* Add it to the list first to present a consistent state in block_reserved
signal. */
blocks.push_back(block);
+
+ bool first_reserve = (cur_blocks_end==blocks.end());
+ if(first_reserve)
+ --cur_blocks_end;
+
try
{
if(!block->reserve(&train))
{
+ if(first_reserve)
+ cur_blocks_end = blocks.end();
blocks.pop_back();
return false;
}
}
catch(...)
{
+ if(first_reserve)
+ cur_blocks_end = blocks.end();
blocks.pop_back();
throw;
}
void BlockAllocator::advance_back()
{
- const Vehicle &veh = train.get_vehicle(train.get_controller().get_reverse() ? 0 : train.get_n_vehicles()-1);
- const Block &veh_block = veh.get_track()->get_block();
+ bool rev = train.get_controller().get_reverse();
+ const Vehicle &veh = train.get_vehicle(rev ? 0 : train.get_n_vehicles()-1);
+ const Block &veh_block = veh.get_placement().get_position(rev ? VehiclePlacement::FRONT_AXLE : VehiclePlacement::BACK_AXLE)->get_block();
/* Sensors aren't guaranteed to be detriggered in order. Go through the
block list and locate the first sensor that's still active. */
- Sensor *last_inactive = 0;
- for(BlockList::iterator i=blocks.begin(); (i!=cur_blocks_end && i->block()!=&veh_block); ++i)
+ BlockList::iterator end = blocks.end();
+ for(BlockList::iterator i=blocks.begin(); i!=cur_blocks_end; ++i)
{
+ Block *block = &**i;
list<Sensor *> sensors;
- if(Sensor *sensor = (*i)->get_sensor())
- sensors.push_back(sensor);
- Block *block = &**i;
+ /* Collect all sensors from the block in the order they are expected to
+ detrigger. */
for(TrackIter j=i->track_iter(); (j && &j->get_block()==block); j=j.next())
if(!j->get_attachments().empty())
{
sensors.push_back(gate);
}
- for(list<Sensor *>::const_iterator j=sensors.begin(); j!=sensors.end(); ++j)
+ if(Sensor *sensor = (*i)->get_sensor())
+ sensors.push_back(sensor);
+
+ /* See if any sensor is still active, and record the position of the
+ last inactive sensor. */
+ bool active_sensor = false;
+ for(list<Sensor *>::const_iterator j=sensors.begin(); (!active_sensor && j!=sensors.end()); ++j)
{
if((*j)->get_state())
+ active_sensor = true;
+ else
+ end = i;
+ }
+
+ // Stop if we encounter an active sensor or the train's last vehicle
+ if(block==&veh_block || active_sensor)
+ {
+ if(end!=blocks.end())
{
- if(last_inactive)
- {
- if(dynamic_cast<BeamGate *>(*j))
- ++i;
- release_blocks_begin(i);
- }
- return;
+ /* If the last inactive sensor was in an earlier block, release
+ that block as well. */
+ if(i!=end)
+ ++end;
+ release_blocks_begin(end);
}
- else
- last_inactive = *j;
+ return;
}
}
}
void BlockAllocator::turnout_path_changing(Track &track)
{
- BlockList::iterator i = find_if(blocks.begin(), blocks.end(), BlockMatch(track.get_block()));
+ BlockList::iterator i = find_if(cur_blocks_end, blocks.end(), BlockMatch(track.get_block()));
if(i!=blocks.end())
{
++i;