src/AIModel/AICarrier.cxx

   1 // FGAICarrier - FGAIShip-derived class creates an AI aircraft carrier
   2 //
   3 // Written by David Culp, started October 2004.
   4 // - davidculp2@comcast.net
   5 //
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License as
   8 // published by the Free Software Foundation; either version 2 of the
   9 // License, or (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful, but
  12 // WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19
  20 #ifdef HAVE_CONFIG_H
  21 #  include <config.h>
  22 #endif
  23
  24 #include <algorithm>
  25 #include <string>
  26 #include <vector>
  27
  28 #include <simgear/sg_inlines.h>
  29 #include <simgear/math/sg_geodesy.hxx>
  30
  31 #include <cmath>
  32 #include <Main/util.hxx>
  33 #include <Main/globals.hxx>
  34 #include <Main/fg_props.hxx>
  35
  36 #include "AICarrier.hxx"
  37
  38 FGAICarrier::FGAICarrier() : FGAIShip(otCarrier) {
  39 }
  40
  41 FGAICarrier::~FGAICarrier() {
  42 }
  43
  44 void FGAICarrier::readFromScenario(SGPropertyNode* scFileNode) {
  45   if (!scFileNode)
  46     return;
  47
  48   FGAIShip::readFromScenario(scFileNode);
  49
  50   setRadius(scFileNode->getDoubleValue("turn-radius-ft", 2000));
  51   setSign(scFileNode->getStringValue("pennant-number"));
  52   setWind_from_east(scFileNode->getDoubleValue("wind_from_east", 0));
  53   setWind_from_north(scFileNode->getDoubleValue("wind_from_north", 0));
  54   setTACANChannelID(scFileNode->getStringValue("TACAN-channel-ID", "029Y"));
  55   setMaxLat(scFileNode->getDoubleValue("max-lat", 0));
  56   setMinLat(scFileNode->getDoubleValue("min-lat", 0));
  57   setMaxLong(scFileNode->getDoubleValue("max-long", 0));
  58   setMinLong(scFileNode->getDoubleValue("min-long", 0));
  59   setMPControl(scFileNode->getBoolValue("mp-control", false));
  60   setAIControl(scFileNode->getBoolValue("ai-control", false));
  61   setCallSign(scFileNode->getStringValue("callsign", ""));
  62
  63
  64   SGPropertyNode* flols = scFileNode->getChild("flols-pos");
  65   if (flols) {
  66     // Transform to the right coordinate frame, configuration is done in
  67     // the usual x-back, y-right, z-up coordinates, computations
  68     // in the simulation usual body x-forward, y-right, z-down coordinates
  69     flols_off(0) = - flols->getDoubleValue("x-offset-m", 0);
  70     flols_off(1) = flols->getDoubleValue("y-offset-m", 0);
  71     flols_off(2) = - flols->getDoubleValue("z-offset-m", 0);
  72   } else
  73     flols_off = SGVec3d::zeros();
  74
  75   std::vector<SGPropertyNode_ptr> props = scFileNode->getChildren("parking-pos");
  76   std::vector<SGPropertyNode_ptr>::const_iterator it;
  77   for (it = props.begin(); it != props.end(); ++it) {
  78     const string name = (*it)->getStringValue("name", "unnamed");
  79     // Transform to the right coordinate frame, configuration is done in
  80     // the usual x-back, y-right, z-up coordinates, computations
  81     // in the simulation usual body x-forward, y-right, z-down coordinates
  82     double offset_x = -(*it)->getDoubleValue("x-offset-m", 0);
  83     double offset_y = (*it)->getDoubleValue("y-offset-m", 0);
  84     double offset_z = -(*it)->getDoubleValue("z-offset-m", 0);
  85     double hd = (*it)->getDoubleValue("heading-offset-deg", 0);
  86     ParkPosition pp(name, SGVec3d(offset_x, offset_y, offset_z), hd);
  87     ppositions.push_back(pp);
  88   }
  89 }
  90
  91 void FGAICarrier::setWind_from_east(double fps) {
  92     wind_from_east = fps;
  93 }
  94
  95 void FGAICarrier::setWind_from_north(double fps) {
  96     wind_from_north = fps;
  97 }
  98
  99 void FGAICarrier::setMaxLat(double deg) {
 100     max_lat = fabs(deg);
 101 }
 102
 103 void FGAICarrier::setMinLat(double deg) {
 104     min_lat = fabs(deg);
 105 }
 106
 107 void FGAICarrier::setMaxLong(double deg) {
 108     max_long = fabs(deg);
 109 }
 110
 111 void FGAICarrier::setMinLong(double deg) {
 112     min_long = fabs(deg);
 113 }
 114
 115 void FGAICarrier::setSign(const string& s) {
 116     sign = s;
 117 }
 118
 119 void FGAICarrier::setTACANChannelID(const string& id) {
 120     TACAN_channel_id = id;
 121 }
 122
 123 void FGAICarrier::setMPControl(bool c) {
 124     MPControl = c;
 125 }
 126
 127 void FGAICarrier::setAIControl(bool c) {
 128     AIControl = c;
 129 }
 130
 131 void FGAICarrier::update(double dt) {
 132     // Now update the position and heading. This will compute new hdg and
 133     // roll values required for the rotation speed computation.
 134     FGAIShip::update(dt);
 135
 136     //automatic turn into wind with a target wind of 25 kts otd
 137     //SG_LOG(SG_AI, SG_ALERT, "AICarrier: MPControl " << MPControl << " AIControl " << AIControl);
 138     if (!MPControl && AIControl){
 139
 140         if(turn_to_launch_hdg){
 141             TurnToLaunch();
 142         } else if(turn_to_recovery_hdg ){
 143             TurnToRecover();
 144         } else if(OutsideBox() || returning ) {// check that the carrier is inside
 145             ReturnToBox();                     // the operating box,
 146         } else {
 147             TurnToBase();
 148         }
 149
 150     } else {
 151         FGAIShip::TurnTo(tgt_heading);
 152         FGAIShip::AccelTo(tgt_speed);
 153     }
 154
 155     UpdateWind(dt);
 156     UpdateElevator(dt, transition_time);
 157     UpdateJBD(dt, jbd_transition_time);
 158
 159     // Transform that one to the horizontal local coordinate system.
 160     SGQuatd ec2hl = SGQuatd::fromLonLat(pos);
 161     // The orientation of the carrier wrt the horizontal local frame
 162     SGQuatd hl2body = SGQuatd::fromYawPitchRollDeg(hdg, pitch, roll);
 163     // and postrotate the orientation of the AIModel wrt the horizontal
 164     // local frame
 165     SGQuatd ec2body = ec2hl*hl2body;
 166     // The cartesian position of the carrier in the wgs84 world
 167     SGVec3d cartPos = SGVec3d::fromGeod(pos);
 168
 169     // The position of the eyepoint - at least near that ...
 170     SGVec3d eyePos(globals->get_view_position_cart());
 171     // Add the position offset of the AIModel to gain the earth
 172     // centered position
 173     SGVec3d eyeWrtCarrier = eyePos - cartPos;
 174     // rotate the eyepoint wrt carrier vector into the carriers frame
 175     eyeWrtCarrier = ec2body.transform(eyeWrtCarrier);
 176     // the eyepoints vector wrt the flols position
 177     SGVec3d eyeWrtFlols = eyeWrtCarrier - flols_off;
 178
 179     // the distance from the eyepoint to the flols
 180     dist = norm(eyeWrtFlols);
 181
 182     // now the angle, positive angles are upwards
 183     if (fabs(dist) < SGLimits<float>::min()) {
 184       angle = 0;
 185     } else {
 186       double sAngle = -eyeWrtFlols(2)/dist;
 187       sAngle = SGMiscd::min(1, SGMiscd::max(-1, sAngle));
 188       angle = SGMiscd::rad2deg(asin(sAngle));
 189     }
 190
 191     // set the value of source
 192     if ( angle <= 4.35 && angle > 4.01 )
 193       source = 1;
 194     else if ( angle <= 4.01 && angle > 3.670 )
 195       source = 2;
 196     else if ( angle <= 3.670 && angle > 3.330 )
 197       source = 3;
 198     else if ( angle <= 3.330 && angle > 2.990 )
 199       source = 4;
 200     else if ( angle <= 2.990 && angle > 2.650 )
 201       source = 5;
 202     else if ( angle <= 2.650 )
 203       source = 6;
 204     else
 205       source = 0;
 206 } //end update
 207
 208 bool FGAICarrier::init(bool search_in_AI_path) {
 209     if (!FGAIShip::init(search_in_AI_path))
 210         return false;
 211
 212     _longitude_node = fgGetNode("/position/longitude-deg", true);
 213     _latitude_node = fgGetNode("/position/latitude-deg", true);
 214     _altitude_node = fgGetNode("/position/altitude-ft", true);
 215
 216     _launchbar_state_node = fgGetNode("/gear/launchbar/state", true);
 217
 218     _surface_wind_from_deg_node =
 219             fgGetNode("/environment/config/boundary/entry[0]/wind-from-heading-deg", true);
 220     _surface_wind_speed_node =
 221             fgGetNode("/environment/config/boundary/entry[0]/wind-speed-kt", true);
 222
 223
 224     turn_to_launch_hdg = false;
 225     turn_to_recovery_hdg = false;
 226     turn_to_base_course = true;
 227     returning = false;
 228     in_to_wind = false;
 229
 230     mOpBoxPos = pos;
 231     base_course = hdg;
 232     base_speed = speed;
 233
 234     pos_norm = raw_pos_norm = 0;
 235     elevators = false;
 236     transition_time = 150;
 237     time_constant = 0.005;
 238     jbd_pos_norm = raw_jbd_pos_norm = 0;
 239     jbd = false ;
 240     jbd_transition_time = 3;
 241     jbd_time_constant = 0.1;
 242     return true;
 243 }
 244
 245 void FGAICarrier::bind() {
 246     FGAIShip::bind();
 247
 248     props->untie("velocities/true-airspeed-kt");
 249
 250     tie("controls/flols/source-lights",
 251         SGRawValuePointer<int>(&source));
 252     tie("controls/flols/distance-m",
 253         SGRawValuePointer<double>(&dist));
 254     tie("controls/flols/angle-degs",
 255         SGRawValuePointer<double>(&angle));
 256     tie("controls/turn-to-launch-hdg",
 257         SGRawValuePointer<bool>(&turn_to_launch_hdg));
 258     tie("controls/in-to-wind",
 259         SGRawValuePointer<bool>(&turn_to_launch_hdg));
 260     tie("controls/base-course-deg",
 261         SGRawValuePointer<double>(&base_course));
 262     tie("controls/base-speed-kts",
 263         SGRawValuePointer<double>(&base_speed));
 264     tie("controls/start-pos-lat-deg",
 265         SGRawValueMethods<SGGeod,double>(pos, &SGGeod::getLatitudeDeg));
 266     tie("controls/start-pos-long-deg",
 267         SGRawValueMethods<SGGeod,double>(pos, &SGGeod::getLongitudeDeg));
 268     tie("controls/mp-control",
 269         SGRawValuePointer<bool>(&MPControl));
 270     tie("controls/ai-control",
 271         SGRawValuePointer<bool>(&AIControl));
 272     tie("environment/surface-wind-speed-true-kts",
 273         SGRawValuePointer<double>(&wind_speed_kts));
 274     tie("environment/surface-wind-from-true-degs",
 275         SGRawValuePointer<double>(&wind_from_deg));
 276     tie("environment/rel-wind-from-degs",
 277         SGRawValuePointer<double>(&rel_wind_from_deg));
 278     tie("environment/rel-wind-from-carrier-hdg-degs",
 279         SGRawValuePointer<double>(&rel_wind));
 280     tie("environment/rel-wind-speed-kts",
 281         SGRawValuePointer<double>(&rel_wind_speed_kts));
 282     tie("environment/in-to-wind",
 283         SGRawValuePointer<bool>(&in_to_wind));
 284     //tie("controls/flols/wave-off-lights",
 285     //    SGRawValuePointer<bool>(&wave_off_lights));
 286     tie("controls/elevators",
 287         SGRawValuePointer<bool>(&elevators));
 288     tie("surface-positions/elevators-pos-norm",
 289         SGRawValuePointer<double>(&pos_norm));
 290     tie("controls/constants/elevators/trans-time-s",
 291         SGRawValuePointer<double>(&transition_time));
 292     tie("controls/constants/elevators/time-constant",
 293         SGRawValuePointer<double>(&time_constant));
 294     tie("controls/jbd",
 295         SGRawValuePointer<bool>(&jbd));
 296     tie("surface-positions/jbd-pos-norm",
 297         SGRawValuePointer<double>(&jbd_pos_norm));
 298     tie("controls/constants/jbd/trans-time-s",
 299         SGRawValuePointer<double>(&jbd_transition_time));
 300     tie("controls/constants/jbd/time-constant",
 301         SGRawValuePointer<double>(&jbd_time_constant));
 302     tie("controls/turn-to-recovery-hdg",
 303         SGRawValuePointer<bool>(&turn_to_recovery_hdg));
 304     tie("controls/turn-to-base-course",
 305         SGRawValuePointer<bool>(&turn_to_base_course));
 306
 307     props->setBoolValue("controls/flols/cut-lights", false);
 308     props->setBoolValue("controls/flols/wave-off-lights", false);
 309     props->setBoolValue("controls/flols/cond-datum-lights", true);
 310     props->setBoolValue("controls/crew", false);
 311     props->setStringValue("navaids/tacan/channel-ID", TACAN_channel_id.c_str());
 312     props->setStringValue("sign", sign.c_str());
 313     props->setBoolValue("controls/lighting/deck-lights", false);
 314     props->setDoubleValue("controls/lighting/flood-lights-red-norm", 0);
 315 }
 316
 317 bool FGAICarrier::getParkPosition(const string& id, SGGeod& geodPos,
 318                                   double& hdng, SGVec3d& uvw)
 319 {
 320
 321     // FIXME: does not yet cover rotation speeds.
 322     list<ParkPosition>::iterator it = ppositions.begin();
 323     while (it != ppositions.end()) {
 324         // Take either the specified one or the first one ...
 325         if ((*it).name == id || id.empty()) {
 326             ParkPosition ppos = *it;
 327             SGVec3d cartPos = getCartPosAt(ppos.offset);
 328             geodPos = SGGeod::fromCart(cartPos);
 329             hdng = hdg + ppos.heading_deg;
 330             double shdng = sin(ppos.heading_deg * SGD_DEGREES_TO_RADIANS);
 331             double chdng = cos(ppos.heading_deg * SGD_DEGREES_TO_RADIANS);
 332             double speed_fps = speed*1.6878099;
 333             uvw = SGVec3d(chdng*speed_fps, shdng*speed_fps, 0);
 334             return true;
 335         }
 336         ++it;
 337     }
 338
 339     return false;
 340 }
 341
 342 // find relative wind
 343 void FGAICarrier::UpdateWind( double dt) {
 344
 345     //get the surface wind speed and direction
 346     wind_from_deg = _surface_wind_from_deg_node->getDoubleValue();
 347     wind_speed_kts  = _surface_wind_speed_node->getDoubleValue();
 348
 349     //calculate the surface wind speed north and east in kts
 350     double wind_speed_from_north_kts = cos( wind_from_deg / SGD_RADIANS_TO_DEGREES )* wind_speed_kts ;
 351     double wind_speed_from_east_kts  = sin( wind_from_deg / SGD_RADIANS_TO_DEGREES )* wind_speed_kts ;
 352
 353     //calculate the carrier speed north and east in kts
 354     double speed_north_kts = cos( hdg / SGD_RADIANS_TO_DEGREES )* speed ;
 355     double speed_east_kts  = sin( hdg / SGD_RADIANS_TO_DEGREES )* speed ;
 356
 357     //calculate the relative wind speed north and east in kts
 358     double rel_wind_speed_from_east_kts = wind_speed_from_east_kts + speed_east_kts;
 359     double rel_wind_speed_from_north_kts = wind_speed_from_north_kts + speed_north_kts;
 360
 361     //combine relative speeds north and east to get relative windspeed in kts
 362     rel_wind_speed_kts = sqrt((rel_wind_speed_from_east_kts * rel_wind_speed_from_east_kts)
 363     + (rel_wind_speed_from_north_kts * rel_wind_speed_from_north_kts));
 364
 365     //calculate the relative wind direction
 366     rel_wind_from_deg = atan2(rel_wind_speed_from_east_kts, rel_wind_speed_from_north_kts)
 367                             * SG_RADIANS_TO_DEGREES;
 368
 369     //calculate rel wind
 370     rel_wind = rel_wind_from_deg - hdg;
 371     SG_NORMALIZE_RANGE(rel_wind, -180.0, 180.0);
 372
 373     //set in to wind property
 374     InToWind();
 375
 376     //switch the wave-off lights
 377     //if (InToWind())
 378     //   wave_off_lights = false;
 379     //else
 380     //   wave_off_lights = true;
 381
 382     // cout << "rel wind: " << rel_wind << endl;
 383
 384 }// end update wind
 385
 386
 387 void FGAICarrier::TurnToLaunch(){
 388
 389     // calculate tgt heading
 390     if (wind_speed_kts < 3){
 391         tgt_heading = base_course;
 392     } else {
 393         tgt_heading = wind_from_deg;
 394     }
 395
 396     //calculate tgt speed
 397     double tgt_speed = 25 - wind_speed_kts;
 398     if (tgt_speed < 10)
 399         tgt_speed = 10;
 400
 401     //turn the carrier
 402     FGAIShip::TurnTo(tgt_heading);
 403     FGAIShip::AccelTo(tgt_speed);
 404
 405 }
 406
 407 void FGAICarrier::TurnToRecover(){
 408
 409     //these are the rules for adjusting heading to provide a relative wind
 410     //down the angled flightdeck
 411
 412     if (wind_speed_kts < 3){
 413         tgt_heading = base_course + 60;
 414     } else if (rel_wind < -9 && rel_wind >= -180){
 415         tgt_heading = wind_from_deg;
 416     } else if (rel_wind > -7 && rel_wind < 45){
 417         tgt_heading = wind_from_deg + 60;
 418     } else if (rel_wind >=45 && rel_wind < 180){
 419         tgt_heading = wind_from_deg + 45;
 420     } else
 421         tgt_heading = hdg;
 422
 423     SG_NORMALIZE_RANGE(tgt_heading, 0.0, 360.0);
 424
 425     //calculate tgt speed
 426     double tgt_speed = 26 - wind_speed_kts;
 427     if (tgt_speed < 10)
 428         tgt_speed = 10;
 429
 430     //turn the carrier
 431     FGAIShip::TurnTo(tgt_heading);
 432     FGAIShip::AccelTo(tgt_speed);
 433
 434 }
 435 void FGAICarrier::TurnToBase(){
 436
 437     //turn the carrier
 438     FGAIShip::TurnTo(base_course);
 439     FGAIShip::AccelTo(base_speed);
 440
 441 }
 442
 443
 444 void FGAICarrier::ReturnToBox(){
 445     double course, distance, az2;
 446
 447     //calculate the bearing and range of the initial position from the carrier
 448     geo_inverse_wgs_84(pos, mOpBoxPos, &course, &az2, &distance);
 449
 450     distance *= SG_METER_TO_NM;
 451
 452     //cout << "return course: " << course << " distance: " << distance << endl;
 453     //turn the carrier
 454     FGAIShip::TurnTo(course);
 455     FGAIShip::AccelTo(base_speed);
 456
 457     if (distance >= 1)
 458         returning = true;
 459     else
 460         returning = false;
 461
 462 } //  end turn to base
 463
 464
 465 bool FGAICarrier::OutsideBox() { //returns true if the carrier is outside operating box
 466
 467     if ( max_lat == 0 && min_lat == 0 && max_long == 0 && min_long == 0) {
 468         SG_LOG(SG_AI, SG_DEBUG, "AICarrier: No Operating Box defined" );
 469         return false;
 470     }
 471
 472     if (mOpBoxPos.getLatitudeDeg() >= 0) { //northern hemisphere
 473         if (pos.getLatitudeDeg() >= mOpBoxPos.getLatitudeDeg() + max_lat)
 474             return true;
 475
 476         if (pos.getLatitudeDeg() <= mOpBoxPos.getLatitudeDeg() - min_lat)
 477             return true;
 478
 479     } else {                  //southern hemisphere
 480         if (pos.getLatitudeDeg() <= mOpBoxPos.getLatitudeDeg() - max_lat)
 481             return true;
 482
 483         if (pos.getLatitudeDeg() >= mOpBoxPos.getLatitudeDeg() + min_lat)
 484             return true;
 485     }
 486
 487     if (mOpBoxPos.getLongitudeDeg() >=0) { //eastern hemisphere
 488         if (pos.getLongitudeDeg() >= mOpBoxPos.getLongitudeDeg() + max_long)
 489             return true;
 490
 491         if (pos.getLongitudeDeg() <= mOpBoxPos.getLongitudeDeg() - min_long)
 492             return true;
 493
 494     } else {                 //western hemisphere
 495         if (pos.getLongitudeDeg() <= mOpBoxPos.getLongitudeDeg() - max_long)
 496             return true;
 497
 498         if (pos.getLongitudeDeg() >= mOpBoxPos.getLongitudeDeg() + min_long)
 499             return true;
 500     }
 501
 502     return false;
 503
 504 } // end OutsideBox
 505
 506
 507 bool FGAICarrier::InToWind() {
 508     in_to_wind = false;
 509
 510     if ( fabs(rel_wind) < 10 ){
 511         in_to_wind = true;
 512         return true;
 513     }
 514     return false;
 515 }
 516
 517
 518 void FGAICarrier::UpdateElevator(double dt, double transition_time) {
 519
 520     double step = 0;
 521
 522     if ((elevators && pos_norm >= 1 ) || (!elevators && pos_norm <= 0 ))
 523         return;
 524
 525     // move the elevators
 526     if ( elevators ) {
 527         step = dt/transition_time;
 528         if ( step > 1 )
 529             step = 1;
 530     } else {
 531         step = -dt/transition_time;
 532         if ( step < -1 )
 533             step = -1;
 534     }
 535     // assume a linear relationship
 536     raw_pos_norm += step;
 537
 538     //low pass filter
 539     pos_norm = (raw_pos_norm * time_constant) + (pos_norm * (1 - time_constant));
 540
 541     //sanitise the output
 542     if (raw_pos_norm >= 1) {
 543         raw_pos_norm = 1;
 544     } else if (raw_pos_norm <= 0) {
 545         raw_pos_norm = 0;
 546     }
 547     return;
 548
 549 } // end UpdateElevator
 550
 551 void FGAICarrier::UpdateJBD(double dt, double jbd_transition_time) {
 552
 553     const string launchbar_state = _launchbar_state_node->getStringValue();
 554     double step = 0;
 555
 556     if (launchbar_state == "Engaged"){
 557         jbd = true;
 558     } else {
 559         jbd = false;
 560     }
 561
 562     if (( jbd && jbd_pos_norm >= 1 ) || ( !jbd && jbd_pos_norm <= 0 )){
 563         return;
 564     }
 565
 566     // move the jbds
 567     if ( jbd ) {
 568         step = dt/jbd_transition_time;
 569         if ( step > 1 )
 570             step = 1;
 571     } else {
 572         step = -dt/jbd_transition_time;
 573         if ( step < -1 )
 574             step = -1;
 575     }
 576
 577     // assume a linear relationship
 578     raw_jbd_pos_norm += step;
 579
 580     //low pass filter
 581     jbd_pos_norm = (raw_jbd_pos_norm * jbd_time_constant) + (jbd_pos_norm * (1 - jbd_time_constant));
 582
 583     //sanitise the output
 584     if (jbd_pos_norm >= 1) {
 585         jbd_pos_norm = 1;
 586     } else if (jbd_pos_norm <= 0) {
 587         jbd_pos_norm = 0;
 588     }
 589
 590     return;
 591
 592 } // end UpdateJBD