+void FGAIBallistic::handle_impact() {
+
+ // try terrain intersection
+ if(!getHtAGL())
+ return;
+
+ if (_ht_agl_ft <= 0) {
+ SG_LOG(SG_GENERAL, SG_DEBUG, "AIBallistic: terrain impact");
+ report_impact(_elevation_m);
+ _impact_reported = true;
+
+ if (life == -1){
+ invisible = true;
+ } else if (_subID == 0) // kill the AIObject if there is no subsubmodel
+ setDie(true);
+ }
+}
+
+void FGAIBallistic::handle_collision()
+{
+ const FGAIBase *object = manager->calcCollision(pos.getElevationFt(),
+ pos.getLatitudeDeg(),pos.getLongitudeDeg(), _fuse_range);
+
+ if (object) {
+ SG_LOG(SG_GENERAL, SG_DEBUG, "AIBallistic: object hit");
+ report_impact(pos.getElevationM(), object);
+ _collision_reported = true;
+ }
+}
+
+void FGAIBallistic::report_impact(double elevation, const FGAIBase *object)
+{
+ _impact_lat = pos.getLatitudeDeg();
+ _impact_lon = pos.getLongitudeDeg();
+ _impact_elev = elevation;
+ _impact_speed = speed * SG_KT_TO_MPS;
+ _impact_hdg = hdg;
+ _impact_pitch = pitch;
+ _impact_roll = roll;
+
+ SGPropertyNode *n = props->getNode("impact", true);
+ if (object)
+ n->setStringValue("type", object->getTypeString());
+ else
+ n->setStringValue("type", "terrain");
+
+ n->setDoubleValue("longitude-deg", _impact_lon);
+ n->setDoubleValue("latitude-deg", _impact_lat);
+ n->setDoubleValue("elevation-m", _impact_elev);
+ n->setDoubleValue("heading-deg", _impact_hdg);
+ n->setDoubleValue("pitch-deg", _impact_pitch);
+ n->setDoubleValue("roll-deg", _impact_roll);
+ n->setDoubleValue("speed-mps", _impact_speed);
+
+ _impact_report_node->setStringValue(props->getPath());
+}
+
+SGVec3d FGAIBallistic::getCartUserPos() const {
+ SGVec3d cartUserPos = SGVec3d::fromGeod(userpos);
+ return cartUserPos;
+}
+
+SGVec3d FGAIBallistic::getCartHitchPos() const{
+
+ // convert geodetic positions to geocentered
+ SGVec3d cartuserPos = getCartUserPos();
+ SGVec3d cartPos = getCartPos();
+
+ // Transform to the right coordinate frame, configuration is done in
+ // the x-forward, y-right, z-up coordinates (feet), computation
+ // in the simulation usual body x-forward, y-right, z-down coordinates
+ // (meters) )
+ SGVec3d _off(_x_offset * SG_FEET_TO_METER,
+ _y_offset * SG_FEET_TO_METER,
+ -_z_offset * SG_FEET_TO_METER);
+
+ // Transform the user position to the horizontal local coordinate system.
+ SGQuatd hlTrans = SGQuatd::fromLonLat(userpos);
+
+ // and postrotate the orientation of the user model wrt the horizontal
+ // local frame
+ hlTrans *= SGQuatd::fromYawPitchRollDeg(
+ manager->get_user_heading(),
+ manager->get_user_pitch(),
+ manager->get_user_roll());
+
+ // The offset converted to the usual body fixed coordinate system
+ // rotated to the earth-fixed coordinates axis
+ SGVec3d off = hlTrans.backTransform(_off);
+
+ // Add the position offset of the user model to get the geocentered position
+ SGVec3d offsetPos = cartuserPos + off;
+
+ return offsetPos;
+}
+
+void FGAIBallistic::setHitchPos(){
+ // convert the hitch geocentered position to geodetic
+ SGVec3d carthitchPos = getCartHitchPos();
+
+ SGGeodesy::SGCartToGeod(carthitchPos, hitchpos);
+}
+
+double FGAIBallistic::getDistanceLoadToHitch() const {
+ //calculate the distance load to hitch
+ SGVec3d carthitchPos = getCartHitchPos();
+ SGVec3d cartPos = getCartPos();
+
+ SGVec3d diff = carthitchPos - cartPos;
+ double distance = norm(diff);
+ return distance * SG_METER_TO_FEET;
+}
+
+void FGAIBallistic::setHitchVelocity(double dt) {
+ //calculate the distance from the previous hitch position
+ SGVec3d carthitchPos = getCartHitchPos();
+ SGVec3d diff = carthitchPos - _oldcarthitchPos;
+
+ double distance = norm(diff);
+
+ //calculate speed knots
+ speed = (distance/dt) * SG_MPS_TO_KT;
+
+ //now calulate the angle between the old and current hitch positions (degrees)
+ double angle = 0;
+ double daltM = hitchpos.getElevationM() - oldhitchpos.getElevationM();
+
+ if (fabs(distance) < SGLimits<float>::min()) {
+ angle = 0;
+ } else {
+ double sAngle = daltM/distance;
+ sAngle = SGMiscd::min(1, SGMiscd::max(-1, sAngle));
+ angle = SGMiscd::rad2deg(asin(sAngle));
+ }
+
+ _elevation = angle;
+
+ //calculate the bearing of the new hitch position from the old
+ double az1, az2, dist;
+
+ geo_inverse_wgs_84(oldhitchpos, hitchpos, &az1, &az2, &dist);
+
+ _azimuth = az1;
+
+ // and finally store the new values
+ _oldcarthitchPos = carthitchPos;
+ oldhitchpos = hitchpos;
+}
+
+double FGAIBallistic::getElevLoadToHitch() const {
+ // now the angle, positive angles are upwards
+ double distance = getDistanceLoadToHitch() * SG_FEET_TO_METER;
+ double angle = 0;
+ double daltM = hitchpos.getElevationM() - pos.getElevationM();
+
+ if (fabs(distance) < SGLimits<float>::min()) {
+ angle = 0;
+ } else {
+ double sAngle = daltM/distance;
+ sAngle = SGMiscd::min(1, SGMiscd::max(-1, sAngle));
+ angle = SGMiscd::rad2deg(asin(sAngle));
+ }
+
+ return angle;
+}
+
+double FGAIBallistic::getBearingLoadToHitch() const {
+ //calculate the bearing and range of the second pos from the first
+ double az1, az2, distance;
+
+ geo_inverse_wgs_84(pos, hitchpos, &az1, &az2, &distance);
+
+ return az1;
+}
+
+double FGAIBallistic::getRelBrgHitchToUser() const {
+ //calculate the relative bearing
+ double az1, az2, distance;
+
+ geo_inverse_wgs_84(hitchpos, userpos, &az1, &az2, &distance);
+
+ double rel_brg = az1 - hdg;
+
+ if (rel_brg > 180)
+ rel_brg -= 360;
+
+ return rel_brg;
+}
+
+double FGAIBallistic::getElevHitchToUser() const {
+
+ //calculate the distance from the user position
+ SGVec3d carthitchPos = getCartHitchPos();
+ SGVec3d cartuserPos = getCartUserPos();
+
+ SGVec3d diff = cartuserPos - carthitchPos;
+
+ double distance = norm(diff);
+ double angle = 0;
+
+ double daltM = userpos.getElevationM() - hitchpos.getElevationM();
+
+ // now the angle, positive angles are upwards
+ if (fabs(distance) < SGLimits<float>::min()) {
+ angle = 0;
+ } else {
+ double sAngle = daltM/distance;
+ sAngle = SGMiscd::min(1, SGMiscd::max(-1, sAngle));
+ angle = SGMiscd::rad2deg(asin(sAngle));
+ }
+
+ return angle;
+}
+
+void FGAIBallistic::setTgtOffsets(double dt, double coeff){
+ double c = dt / (coeff + dt);
+
+ _x_offset = (_tgt_x_offset * c) + (_x_offset * (1 - c));
+ _y_offset = (_tgt_y_offset * c) + (_y_offset * (1 - c));
+ _z_offset = (_tgt_z_offset * c) + (_z_offset * (1 - c));
+}
+
+void FGAIBallistic::formateToAC(double dt){
+
+ setTgtOffsets(dt, 25);
+ setHitchPos();
+ setHitchVelocity(dt);
+
+ // elapsed time has a random initialisation so that each
+ // wingman moves differently
+ _elapsed_time += dt;
+
+ // we derive a sine based factor to give us smoothly
+ // varying error between -1 and 1
+ double factor = sin(SGMiscd::deg2rad(_elapsed_time * 10));
+ double r_angle = 5 * factor;
+ double p_angle = 2.5 * factor;
+ double h_angle = 5 * factor;
+ double h_feet = 3 * factor;
+
+ pos.setLatitudeDeg(hitchpos.getLatitudeDeg());
+ pos.setLongitudeDeg(hitchpos.getLongitudeDeg());
+
+ if (getHtAGL()){
+
+ if(_ht_agl_ft <= 10) {
+ _height = userpos.getElevationFt();
+ } else if (_ht_agl_ft > 10 && _ht_agl_ft <= 150 ) {
+ setHt(userpos.getElevationFt(), dt, 1.0);
+ } else if (_ht_agl_ft > 150 && _ht_agl_ft <= 250) {
+ setHt(hitchpos.getElevationFt()+ h_feet, dt, 0.75);
+ } else
+ setHt(hitchpos.getElevationFt()+ h_feet, dt, 0.5);
+
+ pos.setElevationFt(_height);
+ }
+
+ // these calculations are unreliable at slow speeds
+ if(speed >= 10) {
+ setHdg(_azimuth + h_angle, dt, 0.9);
+ setPch(_elevation + p_angle + _pitch_offset, dt, 0.9);
+
+ if (roll <= 115 && roll >= -115)
+ setBnk(manager->get_user_roll() + r_angle + _roll_offset, dt, 0.5);
+ else
+ roll = manager->get_user_roll() + r_angle + _roll_offset;
+
+ } else {
+ setHdg(manager->get_user_heading(), dt, 0.9);
+ setPch(manager->get_user_pitch() + _pitch_offset, dt, 0.9);
+ setBnk(manager->get_user_roll() + _roll_offset, dt, 0.9);
+ }
+
+ setSpeed(speed);
+}