X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibr2c2%2Fvehicle.cpp;h=fa44916a19b56cdc5bc5919026917c514994635c;hb=64d23de66c33d0f77454c3db2e40cccc18f7851b;hp=a8c3b48dc2f925e9b00812799f4f4afd0c77c95d;hpb=f23c8d8cbc4e72b45e3a719b2cf974ce35d054e9;p=r2c2.git

diff --git a/source/libr2c2/vehicle.cpp b/source/libr2c2/vehicle.cpp
index a8c3b48..fa44916 100644
--- 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();
@@ -166,46 +166,44 @@ const Vehicle::Rod &Vehicle::get_rod(unsigned i) const
 
 void Vehicle::update_position()
 {
-	TrackPoint tp;
+	OrientedPoint p;
 
 	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);
+		p = 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);
 
 		const vector<Axle> &front_axles = bogies.front().axles;
 		float wheelbase = front_axles.front().type->position-front_axles.back().type->position;
-		TrackPoint front_point = get_point(front, wheelbase, -front_axles.back().type->position/wheelbase);
+		OrientedPoint front_point = get_point(front, wheelbase, -front_axles.back().type->position/wheelbase);
 
 		const vector<Axle> &back_axles = bogies.back().axles;
 		wheelbase = back_axles.front().type->position-back_axles.back().type->position;
-		TrackPoint back_point = get_point(back, wheelbase, -back_axles.back().type->position/wheelbase);
+		OrientedPoint back_point = get_point(back, wheelbase, -back_axles.back().type->position/wheelbase);
 
-		tp = get_point(front_point.pos, back_point.pos, -bogies.back().type->position/bogie_spacing);
+		p = get_point(front_point.position, back_point.position, -bogies.back().type->position/bogie_spacing);
 
-		bogies.front().direction = front_point.dir-tp.dir;
-		bogies.back().direction = back_point.dir-tp.dir;
+		bogies.front().direction = front_point.rotation-p.rotation;
+		bogies.back().direction = back_point.rotation-p.rotation;
 	}
 	else
-		tp = track_pos.get_point();
+		p = track.point();
 
 	if(!prev)
 		check_sensor(type.get_front_axle_offset(), front_sensor);
 	if(!next)
 		check_sensor(type.get_back_axle_offset(), back_sensor);
 
-	position = tp.pos;
+	position = p.position;
 	position.z += layout.get_catalogue().get_rail_elevation();
-	rotation = tp.dir;
+	rotation = p.rotation;
 	signal_moved.emit();
 }
 
@@ -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().position;
+		Vector back_point = back.point().position;
 
 		float dist = distance(front_point, back_point);
 
@@ -370,32 +366,29 @@ 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);
 	}
 }
 
-TrackPoint Vehicle::get_point(const Vector &front, const Vector &back, float ratio) const
+OrientedPoint Vehicle::get_point(const Vector &front, const Vector &back, float ratio) const
 {
 	Vector span = front-back;
 
-	TrackPoint tp;
-	tp.pos = back+span*ratio;
-	tp.dir = Geometry::atan2(span.y, span.x);
+	OrientedPoint p;
+	p.position = back+span*ratio;
+	p.rotation = Geometry::atan2(span.y, span.x);
 
-	return tp;
+	return p;
 }
 
-TrackPoint Vehicle::get_point(const TrackPosition &pos, float tdist, float ratio) const
+OrientedPoint 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().position, back.point().position, 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