-void FGAIMultiplayer::Run(double dt) {
-
- // strangely, this is called with a dt of 0 quite often
-
- SG_LOG( SG_GENERAL, SG_DEBUG, "AIMultiplayer::main loop dt " << dt ) ;
-
- //if (dt == 0) return;
-
- //FGAIMultiplayer::dt = dt;
-
- //double rhr, rha; // "real" heading radius/angle
-
- // get the current sim elapsed time
- double time =_time_node->getDoubleValue(); //secs
-
- dt = 0;
-
- //calulate the time difference, dt. Then use this value to extrapolate position and orientation
- dt = time - time_stamp;
-
- SG_LOG(SG_GENERAL, SG_DEBUG, "time: "
- << time << " timestamp: " << time_stamp << " dt: " << dt << " freq Hz: " << 1/dt);
-
- // change heading/roll/pitch
- raw_hdg = hdg + rateH * dt;
- raw_roll = roll + rateR * dt;
- raw_pitch = pitch + rateP * dt;
-
- //apply lowpass filters
- hdg = (raw_hdg * hdg_constant) + (hdg * (1 - hdg_constant));
- roll = (raw_roll * roll_constant) + (roll * (1 - roll_constant));
- pitch = (raw_pitch * pitch_constant) + (pitch * (1 - pitch_constant));
-
- /*cout << "raw roll " << raw_roll <<" damp hdg " << roll << endl;
- cout << "raw hdg" << raw_hdg <<" damp hdg " << hdg << endl;
- cout << "raw pitch " << raw_pitch <<" damp pitch " << pitch << endl;*/
-
- // sanitize HRP
- while (hdg < 0) hdg += 360;
- while (hdg >= 360) hdg -= 360;
- while (roll <= -180) roll += 360;
- while (roll > 180) roll -= 360;
- while (pitch <= -180) pitch += 360;
- while (pitch > 180) pitch -= 360;
-
- // calculate the new accelerations by change in the rate of heading
- /*rhr = sqrt(pow(accN,2) + pow(accE,2));
- rha = atan2(accN, accE);
- rha += rateH * dt;
- accN = sin(rha);
- accE = cos(rha);*/
-
- // calculate new speed by acceleration
- speedN += accN * dt;
- speedE += accE * dt;
- speedD += accD * dt;
-
- // convert speed to degrees per second
- // 1.686
- speed_north_deg_sec = speedN / ft_per_deg_lat;
- speed_east_deg_sec = speedE / ft_per_deg_lon;
-
- // calculate new position by speed
- raw_lat = pos.lat() + speed_north_deg_sec * dt;
- raw_lon = pos.lon() + speed_east_deg_sec * dt ;
- raw_alt = (pos.elev() / SG_FEET_TO_METER) + (speedD * dt);
-
- //apply lowpass filters if the difference is small
- if ( fabs ( pos.lat() - raw_lat) < 0.001 ) {
- SG_LOG(SG_GENERAL, SG_DEBUG,"lat lowpass filter");
- damp_lat = (raw_lat * lat_constant) + (damp_lat * (1 - lat_constant));
- }else {
- // skip the filter
- SG_LOG(SG_GENERAL, SG_DEBUG,"lat high pass filter");
- damp_lat = raw_lat;
+void FGAIMultiplayer::update(double dt)
+{
+ using namespace simgear;
+
+ if (dt <= 0)
+ return;
+
+ FGAIBase::update(dt);
+
+ // Check if we already got data
+ if (mMotionInfo.empty())
+ return;
+
+ // The current simulation time we need to update for,
+ // note that the simulation time is updated before calling all the
+ // update methods. Thus it contains the time intervals *end* time
+ double curtime = globals->get_sim_time_sec();
+
+ // Get the last available time
+ MotionInfo::reverse_iterator it = mMotionInfo.rbegin();
+ double curentPkgTime = it->second.time;
+
+ // Dynamically optimize the time offset between the feeder and the client
+ // Well, 'dynamically' means that the dynamic of that update must be very
+ // slow. You would otherwise notice huge jumps in the multiplayer models.
+ // The reason is that we want to avoid huge extrapolation times since
+ // extrapolation is highly error prone. For that we need something
+ // approaching the average latency of the packets. This first order lag
+ // component will provide this. We just take the error of the currently
+ // requested time to the most recent available packet. This is the
+ // target we want to reach in average.
+ double lag = it->second.lag;
+ if (!mTimeOffsetSet) {
+ mTimeOffsetSet = true;
+ mTimeOffset = curentPkgTime - curtime - lag;
+ } else {
+ double offset = curentPkgTime - curtime - lag;
+ if ((!mAllowExtrapolation && offset + lag < mTimeOffset)
+ || (offset - 10 > mTimeOffset)) {
+ mTimeOffset = offset;
+ SG_LOG(SG_AI, SG_DEBUG, "Resetting time offset adjust system to "
+ "avoid extrapolation: time offset = " << mTimeOffset);
+ } else {
+ // the error of the offset, respectively the negative error to avoid
+ // a minus later ...
+ double err = offset - mTimeOffset;
+ // limit errors leading to shorter lag values somehow, that is late
+ // arriving packets will pessimize the overall lag much more than
+ // early packets will shorten the overall lag
+ double sysSpeed;
+ if (err < 0) {
+ // Ok, we have some very late packets and nothing newer increase the
+ // lag by the given speedadjust
+ sysSpeed = mLagAdjustSystemSpeed*err;
+ } else {
+ // We have a too pessimistic display delay shorten that a small bit
+ sysSpeed = SGMiscd::min(0.1*err*err, 0.5);
+ }
+
+ // simple euler integration for that first order system including some
+ // overshooting guard to prevent to aggressive system speeds
+ // (stiff systems) to explode the systems state
+ double systemIncrement = dt*sysSpeed;
+ if (fabs(err) < fabs(systemIncrement))
+ systemIncrement = err;
+ mTimeOffset += systemIncrement;
+
+ SG_LOG(SG_AI, SG_DEBUG, "Offset adjust system: time offset = "
+ << mTimeOffset << ", expected longitudinal position error due to "
+ " current adjustment of the offset: "
+ << fabs(norm(it->second.linearVel)*systemIncrement));
+ }
+ }
+
+
+ // Compute the time in the feeders time scale which fits the current time
+ // we need to
+ double tInterp = curtime + mTimeOffset;
+
+ SGVec3d ecPos;
+ SGQuatf ecOrient;
+ SGVec3f ecLinearVel;
+
+ if (tInterp <= curentPkgTime) {
+ // Ok, we need a time prevous to the last available packet,
+ // that is good ...
+
+ // Find the first packet before the target time
+ MotionInfo::iterator nextIt = mMotionInfo.upper_bound(tInterp);
+ if (nextIt == mMotionInfo.begin()) {
+ SG_LOG(SG_AI, SG_DEBUG, "Taking oldest packet!");
+ // We have no packet before the target time, just use the first one
+ MotionInfo::iterator firstIt = mMotionInfo.begin();
+ ecPos = firstIt->second.position;
+ ecOrient = firstIt->second.orientation;
+ ecLinearVel = firstIt->second.linearVel;
+ speed = norm(ecLinearVel) * SG_METER_TO_NM * 3600.0;
+
+ std::vector<FGPropertyData*>::const_iterator firstPropIt;
+ std::vector<FGPropertyData*>::const_iterator firstPropItEnd;
+ firstPropIt = firstIt->second.properties.begin();
+ firstPropItEnd = firstIt->second.properties.end();
+ while (firstPropIt != firstPropItEnd) {
+ //cout << " Setting property..." << (*firstPropIt)->id;
+ PropertyMap::iterator pIt = mPropertyMap.find((*firstPropIt)->id);
+ if (pIt != mPropertyMap.end())
+ {
+ //cout << "Found " << pIt->second->getPath() << ":";
+ switch ((*firstPropIt)->type) {
+ case props::INT:
+ case props::BOOL:
+ case props::LONG:
+ pIt->second->setIntValue((*firstPropIt)->int_value);
+ //cout << "Int: " << (*firstPropIt)->int_value << "\n";
+ break;
+ case props::FLOAT:
+ case props::DOUBLE:
+ pIt->second->setFloatValue((*firstPropIt)->float_value);
+ //cout << "Flo: " << (*firstPropIt)->float_value << "\n";
+ break;
+ case props::STRING:
+ case props::UNSPECIFIED:
+ pIt->second->setStringValue((*firstPropIt)->string_value);
+ //cout << "Str: " << (*firstPropIt)->string_value << "\n";
+ break;
+ default:
+ // FIXME - currently defaults to float values
+ pIt->second->setFloatValue((*firstPropIt)->float_value);
+ //cout << "Unknown: " << (*firstPropIt)->float_value << "\n";
+ break;
+ }
+ }
+ else
+ {
+ SG_LOG(SG_AI, SG_DEBUG, "Unable to find property: " << (*firstPropIt)->id << "\n");
+ }
+ ++firstPropIt;
+ }
+
+ } else {
+ // Ok, we have really found something where our target time is in between
+ // do interpolation here
+ MotionInfo::iterator prevIt = nextIt;
+ --prevIt;
+
+ // Interpolation coefficient is between 0 and 1
+ double intervalStart = prevIt->second.time;
+ double intervalEnd = nextIt->second.time;
+ double intervalLen = intervalEnd - intervalStart;
+ double tau = (tInterp - intervalStart)/intervalLen;
+
+ SG_LOG(SG_AI, SG_DEBUG, "Multiplayer vehicle interpolation: ["
+ << intervalStart << ", " << intervalEnd << "], intervalLen = "
+ << intervalLen << ", interpolation parameter = " << tau);
+
+ // Here we do just linear interpolation on the position
+ ecPos = ((1-tau)*prevIt->second.position + tau*nextIt->second.position);
+ ecOrient = interpolate((float)tau, prevIt->second.orientation,
+ nextIt->second.orientation);
+ ecLinearVel = ((1-tau)*prevIt->second.linearVel + tau*nextIt->second.linearVel);
+ speed = norm(ecLinearVel) * SG_METER_TO_NM * 3600.0;
+
+ if (prevIt->second.properties.size()
+ == nextIt->second.properties.size()) {
+ std::vector<FGPropertyData*>::const_iterator prevPropIt;
+ std::vector<FGPropertyData*>::const_iterator prevPropItEnd;
+ std::vector<FGPropertyData*>::const_iterator nextPropIt;
+ std::vector<FGPropertyData*>::const_iterator nextPropItEnd;
+ prevPropIt = prevIt->second.properties.begin();
+ prevPropItEnd = prevIt->second.properties.end();
+ nextPropIt = nextIt->second.properties.begin();
+ nextPropItEnd = nextIt->second.properties.end();
+ while (prevPropIt != prevPropItEnd) {
+ PropertyMap::iterator pIt = mPropertyMap.find((*prevPropIt)->id);
+ //cout << " Setting property..." << (*prevPropIt)->id;
+
+ if (pIt != mPropertyMap.end())
+ {
+ //cout << "Found " << pIt->second->getPath() << ":";
+
+ int ival;
+ float val;
+ switch ((*prevPropIt)->type) {
+ case props::INT:
+ case props::BOOL:
+ case props::LONG:
+ ival = (int) (0.5+(1-tau)*((double) (*prevPropIt)->int_value) +
+ tau*((double) (*nextPropIt)->int_value));
+ pIt->second->setIntValue(ival);
+ //cout << "Int: " << ival << "\n";
+ break;
+ case props::FLOAT:
+ case props::DOUBLE:
+ val = (1-tau)*(*prevPropIt)->float_value +
+ tau*(*nextPropIt)->float_value;
+ //cout << "Flo: " << val << "\n";
+ pIt->second->setFloatValue(val);
+ break;
+ case props::STRING:
+ case props::UNSPECIFIED:
+ //cout << "Str: " << (*nextPropIt)->string_value << "\n";
+ pIt->second->setStringValue((*nextPropIt)->string_value);
+ break;
+ default:
+ // FIXME - currently defaults to float values
+ val = (1-tau)*(*prevPropIt)->float_value +
+ tau*(*nextPropIt)->float_value;
+ //cout << "Unk: " << val << "\n";
+ pIt->second->setFloatValue(val);
+ break;
+ }
+ }
+ else
+ {
+ SG_LOG(SG_AI, SG_DEBUG, "Unable to find property: " << (*prevPropIt)->id << "\n");
+ }
+
+ ++prevPropIt;
+ ++nextPropIt;
+ }
+ }
+
+ // Now throw away too old data
+ if (prevIt != mMotionInfo.begin())
+ {
+ --prevIt;
+ mMotionInfo.erase(mMotionInfo.begin(), prevIt);
+ }