fgdata/Aircraft/Generic/MPCarriers.nas

###############################################################################
##
## Nasal module for connecting a local AI carrier to a MP player.
##
##  Copyright (C) 2007 - 2012  Anders Gidenstam  (anders(at)gidenstam.org)
##  Copyright (C) 2009  Vivian Meazza
##  This file is licensed under the GPL license version 2 or later.
##
###############################################################################

# NOTE:
#   This module is intended to be loaded under the name MPCarriers.

# To see what is happening with multiplayer/ai carriers, look in
# /ai/models/carrier[]/mp-control/.
#

# If this is true, we auto-enable ai scenarios and auto-attach ai carriers to
# mp carriers.
#
var g_auto_attach = props.globals.getNode("/sim/mp-carriers/auto-attach", 1);
var g_latch_always = props.globals.getNode("/sim/mp-carriers/latch-always", 1);
printf("fgdata/Aircraft/Generic/MPCarriers.nas: g_auto_attach.getValue()=%s g_latch_always=%s",
        g_auto_attach.getValue(),
        g_latch_always.getValue(),
        );

# Constants
var lat     = "position/latitude-deg";
var lon     = "position/longitude-deg";
var alt     = "position/altitude-ft";
var c_heading = "orientation/true-heading-deg";
var c_pitch   = "orientation/pitch-deg";
var c_roll    = "orientation/roll-deg";
var c_speed   = "velocities/speed-kts";
var x           = "position/global-x";
var y           = "position/global-y";
var z           = "position/global-z";

#var c_control_speed   = "controls/base-speed-kts";
#var c_control_course  = "controls/base-course-deg";
var c_control_speed   = "controls/tgt-speed-kts";
var c_control_course  = "controls/tgt-heading-degs";
var c_wave_off_lights = "controls/flols/wave-off-lights";


var c_control_mp_ctrl = "controls/mp-control";

var c_deck_elev          = "controls/elevators";
var c_deck_lights        = "controls/lighting/deck-lights";
var c_flood_lights       = "controls/lighting/flood-lights-red-norm";
var c_turn_to_launch_hdg = "controls/turn-to-launch-hdg";
var c_turn_to_recvry_hdg = "controls/turn-to-recovery-hdg";
var c_turn_to_base_co    = "controls/turn-to-base-course";


var mp_heading = "orientation/true-heading-deg";
var mp_pitch   = "orientation/pitch-deg";
var mp_roll    = "orientation/roll-deg";

# MP transmitted controls
var mp_speed              = "surface-positions/flap-pos-norm";
var mp_rudder             = "surface-positions/rudder-pos-norm";
var mp_network            = "sim/multiplay/generic/string[0]";
var mp_message            = "sim/multiplay/generic/string[2]";
var mp_tgt_hdg            = "sim/multiplay/generic/float[0]";
var mp_tgt_spd            = "sim/multiplay/generic/float[1]";
var mp_turn_radius        = "sim/multiplay/generic/float[2]";

# Controller parameters.
var cross_course_gain    = 0.2;
var cross_course_fadeout = 100.0;
var cross_course_limit   = 20.0;

###############################################################################
# Manager class for one model instance.
var Manager = {};
##################################################
Manager.new = func (player = nil, carrier_name = nil, callsign = nil) {
  # e.g. carrier_name = 'Clemenceau'.
  printf("Manager.new(): player=%s carrier_name=%s callsign=%s",
        player, carrier_name, callsign);

  if (g_auto_attach.getValue()) {
    # Look for matching ai scenario and enable it. We don't care if it is
    # already enabled - FGAIManager::loadScenarioCommand() will know to do
    # nothing.
    printf("Checking ai scenarios...");
    foreach (var n; props.globals.getNode("sim/ai/scenarios", 1).getChildren("scenario")) {
      var n_carrier_name = n.getValue("carrier/name");
      var n_scenario_id = n.getValue("id"); # e.g. clemenceau_demo.
      if (n_carrier_name != nil) {
        if (0) {
          printf("    %s: id=%s n_carrier_name=%s",
              n.getPath(),
              n_scenario_id,
              n_carrier_name
              );
        }
        if (n_carrier_name == carrier_name) {
          printf("calling load-scenario with id=%s", n_scenario_id);
          var args = props.Node.new( { name: n_scenario_id});
          var e = fgcommand("load-scenario", args);
          printf("fgcommand('load-scenario') returned e=%s", e);
          if (e) {
              # We have loaded scenario. 
              gui.popupTip(sprintf("Have loaded AI senario: %s", n_scenario_id));
          }
          else {
              # Error, or scenario was already loaded.
          }
        }
      }
    }
    printf("Enabled scenarios are:");
    foreach (var n; props.globals.getNode("sim/ai", 1).getChildren("scenario")) {
      printf("    %s", n.getValue());
    }
  }

  var obj = { parents           : [Manager],
              rplayer           : player,
              carrier_name      : carrier_name,
              carrier           : nil,
              accept_callsign   : callsign,
              callsign_listener : nil,
              FREEZE_DIST       : 400.0,
              comms             : nil,
              message           : nil,
              loopid  : 0 };

  var carriers = props.globals.getNode("/ai/models").getChildren("carrier");

  foreach(var c; carriers) {
    if (c.getNode("name").getValue() == carrier_name) {

      obj.carrier = c;
      printf("Initializing carrier_name=%s player.getPath()=%s",
            carrier_name, player.getPath());
      obj.callsign_listener =
        setlistener(callsign,
                    func { print("Callsign update");
                           obj.start(); });
      MPCarriersNW.Manager_instances[player.getIndex()] = obj;
      obj.start();
      return obj;
    }
  }
  printf("Failed to find carrier_name=%s. The relevant carrier AI scenario must be active", carrier_name);
  
  return nil;
}
##################################################
Manager.is_valid = func {
  return ((me.rplayer.getNode("valid") != nil) and
          me.rplayer.getNode("valid").getValue() and
          (me.rplayer.getNode("callsign") != nil));
}
##################################################
Manager.is_active = func {
  var a = me.is_valid();
  var b = (me.rplayer.getNode("callsign") != nil);
  # FIXME: Sometimes the cmp() call here gets an invalid argument.
  var c = (cmp(me.rplayer.getNode("callsign").getValue(), me.accept_callsign.getValue()) == 0);
  if (g_auto_attach.getValue()) {
    # Always attach, regardless of callsign.
    c = 1;
  }
  return (a and b and c);
}
##################################################
Manager.set_property = func (path, value) {
  if (!me.is_valid() or !me.is_active()) return;
  me.carrier.getNode(path).setValue(value);
}
##################################################
Manager.update = func {
  var aircraft_pos = geo.aircraft_position();
  var carrier_pos  = geo.Coord.new(aircraft_pos);

  if (!me.is_valid()) {
    # This carrier player is not valid anymore.
    if (0) printf("calling me.die() because !me.is_valid()");
    me.die();
    return;
  }
  if (!me.is_active()) {
    # This carrier player is not the chosen one. Go idle.
    if (0) printf("calling me.stop(). me.is_valid()=%s me.rplayer.getNode('callsign').getValue()=%s me.accept_callsign.getValue()=%s",
            me.is_valid(),
            me.rplayer.getNode('callsign').getValue(),
            me.accept_callsign.getValue()
            );
    me.stop();
    return;
  }

  # LSO comms
  var message = me.rplayer.getNode(mp_message).getValue();
  if (message != ""){

    if (message != me.message){
      setprop("/sim/messages/approach", message);
    }

    me.message = message;
  }

  if (!g_latch_always.getValue())
  {
  #  carrier_pos.set_latlon(me.carrier.getNode(lat).getValue(),
  #                         me.carrier.getNode(lon).getValue(),
  #                         me.carrier.getNode(alt).getValue());

  carrier_pos.set_xyz(me.carrier.getNode(x).getValue(),
                      me.carrier.getNode(y).getValue(),
                      me.carrier.getNode(z).getValue());

  # Compute the position and orientation error.
  var rplayer_pos  = geo.Coord.new(carrier_pos);
  #  rplayer_pos.set_latlon(me.rplayer.getNode(lat).getValue(),
  #                         me.rplayer.getNode(lon).getValue(),
  #                         me.rplayer.getNode(alt).getValue());

  rplayer_pos.set_xyz(me.rplayer.getNode(x).getValue(),
                      me.rplayer.getNode(y).getValue(),
                      me.rplayer.getNode(z).getValue());
  }
  
  var master_course      = normalize_course(me.rplayer.getNode(mp_heading).getValue());
  var master_speed       = me.rplayer.getNode(mp_speed).getValue();
  var bearing_to_master  = normalize_course(carrier_pos.course_to(rplayer_pos));
  var distance_to_master = carrier_pos.direct_distance_to(rplayer_pos);
  var v                  = D2R * normalize_course(bearing_to_master - master_course);
  var cross_track_error  = distance_to_master * math.sin(v);
  var along_track_error  = distance_to_master * math.cos(v);
  var master_tgt_hdg     = as_num(me.rplayer.getNode(mp_tgt_hdg).getValue(),
                                  me.rplayer.getNode(mp_heading).getValue());
  var master_tgt_spd     = as_num(me.rplayer.getNode(mp_tgt_spd).getValue(),
                                  me.rplayer.getNode(mp_speed).getValue());
  var master_turn_radius = as_num(me.rplayer.getNode(mp_turn_radius).getValue());

  var diff = master_course - master_tgt_hdg;
  
  if (diff > 180)
      diff -= 360;
  elsif (diff < -180)
      diff += 360;

  me.carrier.getNode("mp-control/ai-mp-course-delta", 1).setValue(diff);
  
  if ( diff < -1.0 or diff > 1.0){
      me.carrier.getNode("mp-control/ai-mp-course-delta-type", 1).setValue("major");
      # major course alteration - we'll just use target heading from
      # master until it's nearly complete
      # print("major turn" , diff);
      var set_course = master_tgt_hdg ;
      var correction = 0;

      if (diff < 0){
          correction = -cross_track_error * M2FT;
          # print("stbd turn ", correction);
      } elsif (diff > 0){
          correction = cross_track_error * M2FT;
          # print("port turn ", correction);
      } else {
          correction = 0;
          # print("no turn ", correction);
      }

      me.carrier.getNode("controls/turn-radius-ft", 1).setValue(master_turn_radius + correction);

  } else {
      # Use Controller.
      me.carrier.getNode("mp-control/ai-mp-course-delta-type", 1).setValue("minor");
      me.carrier.getNode("controls/turn-radius-ft", 1).setValue(master_turn_radius);
      var set_course =
        normalize_course(180.0/math.pi *
                         (math.abs(cross_track_error) < cross_course_fadeout ?
                          math.pow
                           (math.abs(cross_track_error/cross_course_fadeout),2) :
                          1.0) *
                         math.atan2(cross_course_gain * cross_track_error,
                                    along_track_error) +
                         master_course);
      # Limit the course to +/-cross_course_limit degrees off the master's course.
      if (set_course - master_course > cross_course_limit) {
        set_course = normalize_course(master_course + cross_course_limit);
      } else if (set_course - master_course < -cross_course_limit) {
        set_course = normalize_course(master_course - cross_course_limit);
      }

  }
  var spd_diff = master_speed - master_tgt_spd;

  me.carrier.getNode("mp-control/ai-mp-speed-delta", 1).setValue(spd_diff);
  if ( spd_diff < -1 or spd_diff > 1){
      # major speed alteration - we'll just use target speed from
      # master until it's nearly complete
      me.carrier.getNode("mp-control/ai-mp-speed-delta-type", 1).setValue("major");
      var set_speed = master_tgt_spd +
          0.01 * along_track_error;
      if (set_speed > master_tgt_spd + 5.0) set_speed = master_tgt_spd + 5.0;
      if (set_speed < master_tgt_spd - 5.0) set_speed = master_tgt_spd - 5.0;
  } else {
      me.carrier.getNode("mp-control/ai-mp-speed-delta-type", 1).setValue("minor");
      var set_speed  = master_speed +
          0.01 * along_track_error;
      if (set_speed > master_speed + 5.0) set_speed = master_speed + 5.0;
      if (set_speed < master_speed - 5.0) set_speed = master_speed - 5.0;
  }

  # publish controller settings to /ai/models/carrier[]/mp-control/.
  #
  me.carrier.getNode("mp-control/bearing-to-master-rel-deg", 1).setValue(v);
  me.carrier.getNode("mp-control/bearing-to-master-deg", 1).setValue(bearing_to_master);
  me.carrier.getNode("mp-control/distance-to-master-m", 1).setValue(distance_to_master);
  me.carrier.getNode("mp-control/cross-track-error-m", 1).setValue(cross_track_error);
  me.carrier.getNode("mp-control/along-track-error-m", 1).setValue(along_track_error);
  me.carrier.getNode("mp-control/freeze-distance", 1).setValue(me.FREEZE_DIST);

  me.carrier.getNode("mp-control/master-speed-kts", 1).setValue(master_speed);
  me.carrier.getNode("mp-control/master-course-deg", 1).setValue(master_course);

  me.carrier.getNode("mp-control/set-speed-kts", 1).setValue(set_speed);
  me.carrier.getNode("mp-control/set-course-deg", 1).setValue(set_course);
  me.carrier.getNode("mp-control/tgt-hdg-deg", 1).setValue(sprintf ( "%03.1d", master_tgt_hdg));
  me.carrier.getNode("mp-control/tgt-spd-kts", 1).setValue(master_tgt_spd);
  me.carrier.getNode("mp-control/turn-radius-ft", 1).setValue(master_turn_radius);

  # We latch ai and mp carrier positions if user aircraft is more than
  # me.FREEZE_DIST away from ai carrier, or if we are in replay mode.
  #
  var distance_aircraft_carrier = aircraft_pos.direct_distance_to(carrier_pos);
  var in_replay = props.globals.getValue("/sim/replay/replay-state");
  var do_latch = (distance_aircraft_carrier > me.FREEZE_DIST or in_replay);
  var distance_ai_to_mpcarrier = rplayer_pos.direct_distance_to(carrier_pos);
  
  me.carrier.getNode("mp-control/aircraft-ai-distance", 1).setValue(distance_aircraft_carrier);
  me.carrier.getNode("mp-control/ai-mp-latched", do_latch);
  
  if (g_latch_always.getValue()) {
    # Tell C++ to copy MP position/orientation directly on to AI
    # position/orientation, every frame.
    #
    # Set /ai/models/multiplayer[]/ai-latch to "/ai/models/carrier[]".
    #
    # Set /ai/models/carrier[]/ai-latch to "/ai/models/multiplayer[]".
    me.rplayer.getNode("ai-latch", 1).setValue(me.carrier.getPath());
    me.carrier.getNode("ai-latch", 1).setValue(me.rplayer.getPath());
  }
  elsif (do_latch) {
    # Latch the local AI carrier to the remote player's
    # location only when the local player is far enough away not
    # to suffer side effects.
    me.carrier.getNode(lat).setValue(me.rplayer.getNode(lat).getValue());
    me.carrier.getNode(lon).setValue(me.rplayer.getNode(lon).getValue());
    me.carrier.getNode(alt).setValue(me.rplayer.getNode(alt).getValue());

    me.carrier.getNode(c_heading).
      setValue(master_course);
    me.carrier.getNode(c_pitch).
      setValue(me.rplayer.getNode(mp_pitch).getValue());
    me.carrier.getNode(c_roll).
      setValue(me.rplayer.getNode(mp_roll).getValue());

    # Accelerate the AI carrier to the right speed.
    me.carrier.getNode(c_control_speed).
      setValue(master_speed);
  } else {
    # Player on deck. Use the speed controller.
    me.carrier.getNode(c_control_speed).
      setValue(set_speed);
  }

  # Always set these commands.
  me.carrier.getNode(c_control_course).
    setValue(set_course);

  # Switch off AI control for the carrier if available.
  if (me.carrier.getNode(c_control_mp_ctrl) != nil)
    me.carrier.getNode(c_control_mp_ctrl).setBoolValue(1);
}
##################################################
Manager.stop = func {
  me.loopid += 1;
  printf("Manager.stop() me.carrier_name=%s me.rplayer.getPath()=%s",
        me.carrier_name, me.rplayer.getPath());
  # Reenable AI control.
  if (me.carrier.getNode(c_control_mp_ctrl) != nil)
    me.carrier.getNode(c_control_mp_ctrl).setBoolValue(0);
  me.rplayer.getNode("ai-latch").setValue("");
  me.carrier.getNode("ai-latch").setValue("");
}
##################################################
Manager.die = func {
  if (me.callsign_listener == nil) return;

  delete(MPCarriersNW.Manager_instances, me.rplayer.getIndex());
  me.loopid += 1;

  # Delay the reactivation of AI control.
  settimer(func {
    if (me.carrier.getNode(c_control_mp_ctrl) != nil)
      me.carrier.getNode(c_control_mp_ctrl).setBoolValue(0);
  }, 5.0);

  removelistener(me.callsign_listener);
  me.callsign_listener = nil;
  printf("Manager.die(): me.carrier_name=%s me.rplayer.getPath()=%s",
        me.carrier_name, me.rplayer.getPath());
}
##################################################
Manager.start = func {
  me.loopid += 1;
  printf("Manager.start(): me.carrier_name=%s me.rplayer.getPath()=%s",
        me.carrier_name, me.rplayer.getPath());
  me._loop_(me.loopid);
}
##################################################
Manager._loop_ = func(id) {
  id == me.loopid or return;
  me.update();
  settimer(func { me._loop_(id); }, 0);
}
###############################################################################

###############################################################################

#################################################################
var normalize_course = func(c) {
    while (c < 0) c += 360;
    while (c >= 360) c -= 360;
    return c;
}

#################################################################
# Return a hash containing all nearby carrier players
# indexed on MP-carrier type
var find_carrier_players = func {
    var res = {};
    foreach (var c; keys(MPCarriersNW.Manager_instances)) {
        if (MPCarriersNW.Manager_instances[c].is_valid()) {
            var type  = MPCarriersNW.Manager_instances[c].carrier_name;
            var pilot = MPCarriersNW.Manager_instances[c].rplayer;

            if (!contains(res, type)) {
                res[type] = [pilot.getNode("callsign").getValue()];
            } else {
                append(res[type], pilot.getNode("callsign").getValue());
            }
        }
    }
    # debug.dump(res);
    return res;
}

###############################################################################
# MPCarrier selection dialog.
var CARRIER_DLG = 0;
var carrier_dialog = {};
############################################################
carrier_dialog.init = func (x = nil, y = nil) {
    me.x = x;
    me.y = y;
    me.bg = [0, 0, 0, 0.3];    # background color
    me.fg = [[1.0, 1.0, 1.0, 1.0]]; 
    #
    # "private"
    me.title = "MPCarrier";
    me.basenode = props.globals.getNode("/sim/mp-carriers", 1);
    me.dialog = nil;
    me.namenode = props.Node.new({"dialog-name" : me.title });
    me.listeners = [];
    me.players = {};
    me.carriers = { "Nimitz"     : "nimitz-callsign",
                    "Eisenhower" : "eisenhower-callsign",
                    "Truman"     : "truman-callsign",
                    "Foch"       : "foch-callsign",
                    "Clemenceau" : "clemenceau-callsign",
                    "Vinson"     : "vinson-callsign"
                    "Kuznetsov"  : "kuznetsov-callsign",
                    "Liaoning"   : "liaoning-callsign",
                    "Sanantonio" : "sanantonio-callsign"};
}
############################################################
carrier_dialog.create = func {
    if (me.dialog != nil)
        me.close();

    me.dialog = gui.Widget.new();
    gui.dialog[me.title] = me.dialog;
    me.dialog.set("name", me.title);
    if (me.x != nil)
        me.dialog.set("x", me.x);
    if (me.y != nil)
        me.dialog.set("y", me.y);

    me.dialog.set("layout", "vbox");
    me.dialog.set("default-padding", 0);
    var titlebar = me.dialog.addChild("group");
    titlebar.set("layout", "hbox");
    titlebar.addChild("empty").set("stretch", 1);
    titlebar.addChild("text").set("label", "MPCarriers online");
    var w = titlebar.addChild("button");
    w.set("pref-width", 16);
    w.set("pref-height", 16);
    w.set("legend", "");
    w.set("default", 0);
    w.set("key", "esc");
    w.setBinding("nasal", "MPCarriers.carrier_dialog.destroy(); ");
    w.setBinding("dialog-close");
    me.dialog.addChild("hrule");

    var content = me.dialog.addChild("group");
    content.set("layout", "vbox");
    content.set("halign", "center");
    content.set("default-padding", 5);

    # Generate the dialog contents.
    var players_old = me.players;
    me.players = find_carrier_players();
    foreach (var type; keys(me.carriers)) {
        var selected = me.basenode.getNode(me.carriers[type], 1).getValue();
        var tmpbase = me.basenode.getNode(type, 1);

        if (contains(me.players, type)) {
            var i = 0;
            foreach (var p; me.players[type]) {
                var tmp = tmpbase.getNode("b[" ~ i ~ "]", 1);
                tmp.setBoolValue(streq(selected, p));
                var w = content.addChild("checkbox");
                w.node.setValues({"label"    : p ~ "  (" ~ type ~ ")",
                                  "halign"   : "left",
                                  "property" : tmp.getPath()});
                w.setBinding
                    ("nasal",
                     "MPCarriers.carrier_dialog.select_action(" ~
                     "\"" ~ type ~ "\", " ~ i ~ ");");
                i = i + 1;
            }
            if (size(me.players[type]) == 1
                    and (
                        !contains(players_old, type)
                        or size(players_old[type]) == 0
                        or g_auto_attach.getValue()
                    )) {
                # Carrier has just appeared, and there is no other carrier of
                # the same type, so attach our AI carrier to it.
                printf("carrier_dialog.create(): auto-selecting type=%s", type);
                me.select_action(type, 0);
            }
        }
    }
    me.dialog.addChild("hrule");

    # Display the dialog.
    fgcommand("dialog-new", me.dialog.prop());
    fgcommand("dialog-show", me.namenode);
}
############################################################
carrier_dialog.close = func {
    if (me.dialog != nil) {
        me.x = me.dialog.prop().getNode("x", 1).getValue();
        me.y = me.dialog.prop().getNode("y", 1).getValue();
    }
    fgcommand("dialog-close", me.namenode);
}
############################################################
carrier_dialog.destroy = func {
    CARRIER_DLG = 0;
    me.close();
    foreach(var l; me.listeners)
        removelistener(l);
    delete(gui.dialog, "\"" ~ me.title ~ "\"");
}
############################################################
carrier_dialog.show = func {
    # print("Showing MPCarriers dialog!");
    if (!CARRIER_DLG) {
        CARRIER_DLG = int(getprop("/sim/time/elapsed-sec"));
        me.init();
        me.create();
        me._update_(CARRIER_DLG);
    }
}
############################################################
carrier_dialog._redraw_ = func {
    if (me.dialog != nil) {
        me.close();
        me.create();
    }
}
############################################################
carrier_dialog._update_ = func (id) {
    if (CARRIER_DLG != id) return;
    me._redraw_();
    settimer(func { me._update_(id); }, 4.1);
}
############################################################
carrier_dialog.select_action = func (type, n) {
    var base = me.basenode.getNode(type);
    var selected = me.basenode.getNode(me.carriers[type]).getValue();
    var bs = base.getChildren();
    # Assumption: There are two true b:s or none. The one not matching selected
    #             is the new selection.
    var i = 0;
    me.basenode.getNode(me.carriers[type], 1).setValue("");
    foreach (var b; bs) {
        if (!b.getValue() and (i == n)) {
            b.setValue(1);
            me.basenode.getNode(me.carriers[type]).setValue
                (me.players[type][i]);
        } else {
            b.setValue(0);
        }
        i = i + 1;
    }
    me._redraw_();
}
###############################################################################

var as_num = func (val, default=0.0) {
    return (typeof(val) == "scalar") ? val : default;
}

###############################################################################
# Overall initialization. Should only take place when the MPCarrier module is
# being loaded.

# Load the MPCarrier MP network.
if (!contains(globals, "MPCarriersNW")) {
  var base = "Aircraft/MPCarrier/Systems/mp-network.nas";
  io.load_nasal(resolvepath(base), "MPCarriersNW");
  MPCarriersNW.mp_network_init(0);
  
}