]> git.tdb.fi Git - r2c2.git/blobdiff - source/libr2c2/train.cpp
Tighten safety measures
[r2c2.git] / source / libr2c2 / train.cpp
index aa6cc481855ff3655ad2e29ff7ad65bdc5db66d1..91387d85297e7f2a6b5bed13a1b620cf01f687b9 100644 (file)
@@ -40,7 +40,6 @@ Train::Train(Layout &l, const VehicleType &t, unsigned a, const string &p):
        speed_changing(false),
        reverse(false),
        functions(0),
-       travel_dist(0),
        pure_speed(false),
        speed_quantizer(0),
        accurate_position(false),
@@ -192,26 +191,22 @@ void Train::ai_message(const TrainAI::Message &msg)
                (*i)->message(msg);
 }
 
-void Train::place(Block &block, unsigned entry)
+void Train::place(const BlockIter &block)
 {
+       if(!block)
+               throw invalid_argument("Train::place");
        if(controller->get_speed())
                throw logic_error("moving");
 
        set_active(false);
        accurate_position = false;
 
-       allocator.start_from(block, entry);
+       allocator.start_from(block);
 
        if(reverse)
-       {
-               TrackIter track = BlockIter(&block, entry).reverse().track_iter();
-               vehicles.front()->place(*track, track.entry(), 0, Vehicle::FRONT_BUFFER);
-       }
+               vehicles.front()->place(block.reverse().track_iter(), 0, Vehicle::FRONT_BUFFER);
        else
-       {
-               const Block::Endpoint &bep = block.get_endpoint(entry);
-               vehicles.back()->place(*bep.track, bep.track_ep, 0, Vehicle::BACK_BUFFER);
-       }
+               vehicles.back()->place(block.track_iter(), 0, Vehicle::BACK_BUFFER);
 }
 
 void Train::unplace()
@@ -237,7 +232,7 @@ void Train::stop_at(Block *block)
 
 bool Train::free_block(Block &block)
 {
-       if(get_reserved_distance_until(&block, false)<controller->get_braking_distance()*1.3)
+       if(get_reserved_distance_until(&block)<controller->get_braking_distance()*1.3)
                return false;
 
        return allocator.release_from(block);
@@ -257,53 +252,21 @@ void Train::free_noncritical_blocks()
        float margin = 10*layout.get_catalogue().get_scale();
        float min_dist = controller->get_braking_distance()*1.3+margin;
 
-       Vehicle &veh = *(reverse ? vehicles.back() : vehicles.front());
-
-       TrackIter track(veh.get_track(), veh.get_entry());
-       BlockIter block = allocator.first();
-       const BlockIter &last_cur = allocator.last_current();
-       const BlockIter &last = allocator.last();
-       bool in_rsv = false;
-       while(!block->has_track(*track))
-       {
-               if(&*block==&*last_cur)
-                       in_rsv = true;
-               if(&*block==&*last)
-                       break;
-               block = block.next();
-       }
-
-       float dist = veh.get_offset();
-       if(reverse)
-               track.reverse();
-       else
-               dist = track->get_type().get_path_length(track->get_active_path())-dist;
-       dist -= veh.get_type().get_length()/2;
-
-       bool nsens = 0;
-       while(1)
+       BlockIter i = allocator.last_current().next();
+       float dist = 0;
+       bool sensor_seen = false;
+       for(; i->get_train()==this; i=i.next())
        {
-               track = track.next();
-
-               if(!block->has_track(*track))
+               if(dist>min_dist && sensor_seen)
                {
-                       if(&*block==&*last_cur)
-                               in_rsv = true;
-                       if(&*block==&*last)
-                               return;
-                       block = block.next();
-
-                       if(dist>min_dist && nsens>0)
-                       {
-                               allocator.release_from(*block);
-                               return;
-                       }
-
-                       if(in_rsv && block->get_sensor_id())
-                               ++nsens;
+                       allocator.release_from(*i);
+                       return;
                }
 
-               dist += track->get_type().get_path_length(track->get_active_path());
+               dist += i->get_path_length(i.entry());
+
+               if(i->get_sensor_id())
+                       sensor_seen = true;
        }
 }
 
@@ -317,7 +280,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(0)-margin, 0.0f);
 }
 
 void Train::reserve_more()
@@ -374,20 +337,9 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt)
                        set_active(true);
 
                Vehicle &vehicle = *(reverse ? vehicles.back() : vehicles.front());
-               Track *track = vehicle.get_track();
-
-               BlockIter first = allocator.first();
-               BlockIter last_current = allocator.last_current();
-               bool ok = false;
-               for(BlockIter i=first; !ok; i=i.next())
-               {
-                       ok = i->has_track(*track);
-                       if(i==last_current)
-                               break;
-               }
 
                float d = speed*(dt/Time::sec);
-               if(ok)
+               if(allocator.is_block_current(vehicle.get_track()->get_block()))
                {
                        SetFlag setf(advancing);
                        vehicle.advance(reverse ? -d : d);
@@ -402,14 +354,6 @@ void Train::tick(const Time::TimeStamp &t, const Time::TimeDelta &dt)
                        }
                }
        }
-
-       if(!allocator.empty() && !allocator.first()->get_sensor_id())
-       {
-               float dist = get_reserved_distance_until(&*allocator.first(), true);
-
-               if(dist>10*layout.get_catalogue().get_scale())
-                       allocator.release_until(*allocator.first());
-       }
 }
 
 void Train::save(list<DataFile::Statement> &st) const
@@ -486,52 +430,47 @@ void Train::loco_func_event(unsigned addr, unsigned func, bool state)
 
 void Train::block_state_changed(Block &block, Block::State state)
 {
-       if(state==Block::MAYBE_ACTIVE)
+       if(block.get_train()==this && state==Block::MAYBE_ACTIVE)
        {
-               const BlockIter &first = allocator.first();
-               const BlockIter &last_cur = allocator.last_current();
-               bool valid = false;
-               for(BlockIter i=first; !valid; i=i.next())
+               if(last_entry_block)
                {
-                       if(&*i==&block)
-                               valid = true;
-                       if(&*i==&*last_cur)
-                               break;
-               }
+                       float travel_distance = -1;
+                       if(pure_speed && speed_quantizer && current_speed_step>0)
+                               travel_distance = 0;
 
-               if(valid)
-               {
-                       // Compute speed and update related state
-                       float travel_time_secs = (Time::now()-last_entry_time)/Time::sec;
+                       for(BlockIter i=last_entry_block; &*i!=&block; i=i.next())
+                       {
+                               if(i->get_sensor_id())
+                                       return;
+                               if(travel_distance>=0)
+                                       travel_distance += i->get_path_length(i.entry());
+                       }
+
+                       if(travel_distance>0)
+                       {
+                               float travel_time_secs = (Time::now()-last_entry_time)/Time::sec;
+
+                               if(travel_time_secs>=2)
+                                       speed_quantizer->learn(current_speed_step, travel_distance/travel_time_secs, travel_time_secs);
+                       }
+               }
 
-                       if(pure_speed && speed_quantizer && current_speed_step>0 && travel_time_secs>=2)
-                               speed_quantizer->learn(current_speed_step, travel_dist/travel_time_secs, travel_time_secs);
+               last_entry_block = allocator.iter_for(block);
+               last_entry_time = Time::now();
+               pure_speed = true;
+               accurate_position = true;
+               overshoot_dist = 0;
 
-                       travel_dist = 0;
-                       unsigned entry = allocator.get_entry_to_block(block);
-                       for(BlockIter i(&block, entry);; i=i.next())
+               if(!advancing && vehicles.front()->get_track())
+               {
+                       TrackIter track = last_entry_block.track_iter();
+                       if(reverse)
                        {
-                               travel_dist += i->get_path_length(i.entry());
-
-                               if(&*i==&block && !advancing && vehicles.front()->get_track())
-                               {
-                                       TrackIter track = i.track_iter();
-                                       if(reverse)
-                                       {
-                                               track = track.flip();
-                                               vehicles.back()->place(*track, track.entry(), 0, Vehicle::BACK_AXLE);
-                                       }
-                                       else
-                                               vehicles.front()->place(*track, track.entry(), 0, Vehicle::FRONT_AXLE);
-                               }
-
-                               if(i==last_cur)
-                                       break;
+                               track = track.flip();
+                               vehicles.back()->place(track, 0, Vehicle::BACK_AXLE);
                        }
-                       last_entry_time = Time::now();
-                       pure_speed = true;
-                       accurate_position = true;
-                       overshoot_dist = 0;
+                       else
+                               vehicles.front()->place(track, 0, Vehicle::FRONT_AXLE);
                }
        }
 }
@@ -542,65 +481,44 @@ void Train::halt_event(bool h)
                accurate_position = false;
 }
 
-float Train::get_reserved_distance_until(const Block *until_block, bool back) const
+float Train::get_reserved_distance_until(const Block *until_block) const
 {
        if(allocator.empty())
                return 0;
 
-       Vehicle &veh = *(reverse!=back ? vehicles.back() : vehicles.front());
-       const VehicleType &vtype = veh.get_type();
+       Vehicle &veh = *(reverse ? vehicles.back() : vehicles.front());
 
-       TrackIter track(veh.get_track(), veh.get_entry());
+       TrackIter track = veh.get_track_iter();
        if(!track)  // XXX Probably unnecessary
                return 0;
 
-       const BlockIter &first = allocator.first();
-       const BlockIter &last = allocator.last();
-       BlockIter block = first;
-       while(!block->has_track(*track))
-       {
-               if(&*block==&*last)
-                       return 0;
-               block = block.next();
-       }
+       BlockIter block = track.block_iter();
        if(&*block==until_block)
                return 0;
 
-       if(back)
-               block = block.reverse();
-
+       // Account for the vehicle's offset on its current track
        float result = veh.get_offset();
-       if(reverse!=back)
+       if(reverse)
                track = track.reverse();
        else
                result = track->get_type().get_path_length(track->get_active_path())-result;
-       result -= vtype.get_length()/2;
+       result -= veh.get_type().get_length()/2;
 
-       while(1)
-       {
-               track = track.next();
-               if(!track)
-                       break;
+       // Count remaining distance in the vehicle's current block
+       for(track=track.next(); &track->get_block()==&*block; track=track.next())
+               result += track->get_type().get_path_length(track->get_active_path());
 
-               if(!block->has_track(*track))
-               {
-                       if(back)
-                       {
-                               if(&*block==&*first)
-                                       break;
-                       }
-                       else
-                       {
-                               if(&*block==&*last)
-                                       break;
-                       }
-                       block = block.next();
+       const BlockIter &last = allocator.last();
+       if(&*block==&*last)
+               return result;
 
-                       if(&*block==until_block)
-                               break;
-               }
+       // Count any remaining blocks
+       for(block=block.next(); (&*block!=until_block && block->get_train()==this); block=block.next())
+       {
+               result += block->get_path_length(block.entry());
 
-               result += track->get_type().get_path_length(track->get_active_path());
+               if(&*block==&*last)
+                       break;
        }
 
        return result;
@@ -626,7 +544,7 @@ void Train::Loader::finish()
        {
                TrackIter track = obj.allocator.first().track_iter();
                float offset = 2*obj.layout.get_catalogue().get_scale();
-               obj.vehicles.back()->place(*track, track.entry(), offset, Vehicle::BACK_BUFFER);
+               obj.vehicles.back()->place(track, offset, Vehicle::BACK_BUFFER);
        }
 }