Create another track iterator class that holds an offset as well

[r2c2.git] / source / libr2c2 / vehicle.cpp

diff --git a/source/libr2c2/vehicle.cpp b/source/libr2c2/vehicle.cpp
index a8c3b48dc2f925e9b00812799f4f4afd0c77c95d..5ea9e5a8d7cb3089c3a2938573a4a9508b2a9c5c 100644 (file)
--- a/source/libr2c2/vehicle.cpp
+++ b/source/libr2c2/vehicle.cpp
@@ -59,7 +59,7 @@ void Vehicle::attach_back(Vehicle &veh)
        next = &veh;
        veh.prev = this;
 
-       if(track_pos.track)
+       if(track)
                propagate_backward();
 }
 
@@ -98,16 +98,16 @@ void Vehicle::place(const TrackIter &t, float o, PlaceMode m)
        if(!t)
                throw invalid_argument("Vehicle::place");
 
-       track_pos = TrackPosition(t, o);
+       track = TrackOffsetIter(t, o);
 
        if(m==FRONT_AXLE)
-               track_pos.advance(-type.get_front_axle_offset());
+               track = track.advance(-type.get_front_axle_offset());
        else if(m==FRONT_BUFFER)
-               track_pos.advance(-type.get_length()/2);
+               track = track.advance(-type.get_length()/2);
        else if(m==BACK_AXLE)
-               track_pos.advance(-type.get_back_axle_offset());
+               track = track.advance(-type.get_back_axle_offset());
        else if(m==BACK_BUFFER)
-               track_pos.advance(type.get_length()/2);
+               track = track.advance(type.get_length()/2);
 
        update_position();
        propagate_position();
@@ -115,10 +115,10 @@ void Vehicle::place(const TrackIter &t, float o, PlaceMode m)
 
 void Vehicle::unplace()
 {
-       if(!track_pos.track)
+       if(!track)
                return;
 
-       track_pos = TrackPosition();
+       track = TrackOffsetIter();
 
        if(prev)
                prev->unplace();
@@ -128,7 +128,7 @@ void Vehicle::unplace()
 
 void Vehicle::advance(float d)
 {
-       track_pos.advance(d);
+       track = track.advance(d);
        update_position();
        turn_axles(d);
        propagate_position();
@@ -171,14 +171,12 @@ void Vehicle::update_position()
        if(axles.size()>=2)
        {
                float wheelbase = axles.front().type->position-axles.back().type->position;
-               tp = get_point(track_pos, wheelbase, -axles.back().type->position/wheelbase);
+               tp = get_point(track, wheelbase, -axles.back().type->position/wheelbase);
        }
        else if(bogies.size()>=2)
        {
-               TrackPosition front = track_pos;
-               front.advance(bogies.front().type->position);
-               TrackPosition back = track_pos;
-               back.advance(bogies.back().type->position);
+               TrackOffsetIter front = track.advance(bogies.front().type->position);
+               TrackOffsetIter back = track.advance(bogies.back().type->position);
                float bogie_spacing = bogies.front().type->position-bogies.back().type->position;
                adjust_for_distance(front, back, bogie_spacing);
 
@@ -196,7 +194,7 @@ void Vehicle::update_position()
                bogies.back().direction = back_point.dir-tp.dir;
        }
        else
-               tp = track_pos.get_point();
+               tp = track.point();
 
        if(!prev)
                check_sensor(type.get_front_axle_offset(), front_sensor);
@@ -217,16 +215,15 @@ void Vehicle::update_position_from(const Vehicle &veh)
        float margin = layout.get_catalogue().get_scale();
 
        float dist = distance(veh.position, position);
-       if(!track_pos.track || dist<tdist-margin || dist>tdist+margin)
+       if(!track || dist<tdist-margin || dist>tdist+margin)
        {
-               track_pos = veh.track_pos;
-               track_pos.advance(sign*tdist);
+               track = veh.track.advance(sign*tdist);
                update_position();
 
                dist = distance(veh.position, position);
        }
 
-       track_pos.advance(sign*(tdist-dist));
+       track = track.advance(sign*(tdist-dist));
        update_position();
        turn_axles(sign*(tdist-dist));
 }
@@ -257,9 +254,8 @@ void Vehicle::propagate_backward()
 
 void Vehicle::check_sensor(float offset, unsigned &sensor)
 {
-       TrackPosition pos = track_pos;
-       pos.advance(offset);
-       unsigned s = pos.track->get_sensor_id();
+       TrackOffsetIter iter = track.advance(offset);
+       unsigned s = iter->get_sensor_id();
        if(s!=sensor)
        {
                /* Sensor ID under axle has changed.  Deduce movement direction by using
@@ -268,7 +264,7 @@ void Vehicle::check_sensor(float offset, unsigned &sensor)
                more robust would be preferable. */
                unsigned old = sensor;
                sensor = s;
-               unsigned mid = track_pos.track->get_sensor_id();
+               unsigned mid = track->get_sensor_id();
 
                if(s && s!=mid)
                        /* There's a sensor and it's different from mid.  We've just entered
@@ -345,14 +341,14 @@ void Vehicle::update_rods()
        }
 }
 
-void Vehicle::adjust_for_distance(TrackPosition &front, TrackPosition &back, float tdist, float ratio) const
+void Vehicle::adjust_for_distance(TrackOffsetIter &front, TrackOffsetIter &back, float tdist, float ratio) const
 {
        float margin = 0.01*layout.get_catalogue().get_scale();
        int adjust_dir = 0;
        while(1)
        {
-               Vector front_point = front.get_point().pos;
-               Vector back_point = back.get_point().pos;
+               Vector front_point = front.point().pos;
+               Vector back_point = back.point().pos;
 
                float dist = distance(front_point, back_point);
 
@@ -370,8 +366,8 @@ void Vehicle::adjust_for_distance(TrackPosition &front, TrackPosition &back, flo
                else
                        return;
 
-               front.advance(diff*(1-ratio));
-               back.advance(-diff*ratio);
+               front = front.advance(diff*(1-ratio));
+               back = back.advance(-diff*ratio);
        }
 }
 
@@ -386,16 +382,13 @@ TrackPoint Vehicle::get_point(const Vector &front, const Vector &back, float rat
        return tp;
 }
 
-TrackPoint Vehicle::get_point(const TrackPosition &pos, float tdist, float ratio) const
+TrackPoint Vehicle::get_point(const TrackOffsetIter &iter, float tdist, float ratio) const
 {
-       TrackPosition front = pos;
-       front.advance(tdist*(1-ratio));
-
-       TrackPosition back = pos;
-       back.advance(-tdist*ratio);
+       TrackOffsetIter front = iter.advance(tdist*(1-ratio));
+       TrackOffsetIter back = iter.advance(-tdist*ratio);
 
        adjust_for_distance(front, back, tdist, ratio);
-       return get_point(front.get_point().pos, back.get_point().pos, ratio);
+       return get_point(front.point().pos, back.point().pos, ratio);
 }
 
 unsigned Vehicle::get_n_link_slots() const
@@ -439,56 +432,4 @@ Vehicle::Rod::Rod(const VehicleType::Rod &t):
        type(&t)
 { }
 
-
-Vehicle::TrackPosition::TrackPosition():
-       offs(0)
-{ }
-
-Vehicle::TrackPosition::TrackPosition(const TrackIter &t, float o):
-       track(t),
-       offs(o)
-{ }
-
-void Vehicle::TrackPosition::advance(float d)
-{
-       if(!track)
-               return;
-
-       offs += d;
-       while(track)
-       {
-               float path_len = track->get_type().get_path_length(track->get_active_path());
-
-               if(offs>path_len)
-               {
-                       offs -= path_len;
-                       track = track.next();
-               }
-               else
-                       break;
-       }
-
-       while(track && offs<0)
-       {
-               track = track.flip().reverse();
-
-               if(track)
-               {
-                       float path_len = track->get_type().get_path_length(track->get_active_path());
-                       offs += path_len;
-               }
-       }
-
-       if(!track)
-               offs = 0;
-}
-
-TrackPoint Vehicle::TrackPosition::get_point() const
-{
-       if(track)
-               return track->get_point(track.entry(), offs);
-       else
-               return TrackPoint();
-}
-
 } // namespace R2C2