UserVehicles.cpp

Go to the documentation of this file.

/*
 * UserVehicles.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 Chris Wallace
 *
 * Fly! Legacy is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#include "../Include/Globals.h"
#include "../Include/FlyLegacy.h"
#include "../Include/UserVehicles.h"
#include "../Include/Subsystems.h"
#include "../Include/Cameras.h"
#include "../Include/Ui.h"
#include "../Include/Utility.h"

using namespace std;


//
// CSimulatedVehicle
//

CSimulatedVehicle::CSimulatedVehicle (const char* svhFilename)
{
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, svhFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}


int CSimulatedVehicle::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'type':
    // Object type
    ReadTag (&type, stream);
    rc = TAG_READ;
    break;
  case 'mxdt':
    // Minimum simulation frame rate
    ReadUInt (&mxdt, stream);
    rc = TAG_READ;
    break;
  case 'name':
    // Aircraft name
    ReadString (name, 64, stream);
    rc = TAG_READ;
    break;
  case 'acid':
    // Tail number (default)
    ReadString (acid, 64, stream);
    rc = TAG_READ;
    break;
  case 'make':
    // Manufacturer model name
    ReadString (make, 64, stream);
    rc = TAG_READ;
    break;
  case 'emas':
    // Empty mass (slugs)
    ReadFloat (&emas, stream);
    rc = TAG_READ;
    break;
  case 'mine':
    // Moments of Inertia
    ReadVector (&mine, stream);
    rc = TAG_READ;
    break;
  case 'CofG':
    // Default center of gravity, relative to visual model center
    ReadVector (&CofG, stream);
    rc = TAG_READ;
    break;
  case 'imbl':
    // Imbalance limit
    ReadFloat (&imbl, stream);
    rc = TAG_READ;
    break;
  case 'iceR':
    // Ice accumulation rate
    ReadFloat (&iceR, stream);
    rc = TAG_READ;
    break;
  case '000a':
    // Wing area (sq. ft.)
    ReadFloat (&wingarea, stream);
    rc = TAG_READ;
    break;
  case '001a':
    // Wing span (ft.)
    ReadFloat (&wingspan, stream);
    rc = TAG_READ;
    break;
  case '002a':
    // Mean chord (ft.)
    ReadFloat (&meanchord, stream);
    rc = TAG_READ;
    break;
  case 'CEIL':
    // Ceiling (ft.)
    ReadFloat (&ceiling, stream);
    rc = TAG_READ;
    break;
  case '043a':
    // Max cruise speed (kts)
    ReadFloat (&maxcruisespeed, stream);
    rc = TAG_READ;
    break;
  case '044a':
    // Approach speed (kts)
    ReadFloat (&approachspeed, stream);
    rc = TAG_READ;
    break;
  case '045a':
    // Best climb rate (fps)
    ReadFloat (&wingarea, stream);
    rc = TAG_READ;
    break;
  case '048a':
    // Never exceed speed (kts)
    ReadFloat (&vne, stream);
    rc = TAG_READ;
    break;
  case 'saoa':
    // Stall angle of attack
    ReadFloat (&stallaoa, stream);
    rc = TAG_READ;
    break;
  case 'posG':
    // Positive G limit
    ReadFloat (&posG, stream);
    rc = TAG_READ;
    break;
  case 'aoaL':
    // Angle of attack limit
    ReadFloat (&aoaL, stream);
    rc = TAG_READ;
    break;
  case 'negG':
    // Negative G limit
    ReadFloat (&negG, stream);
    rc = TAG_READ;
    break;
  case 'stal':
    // Simple stall speed (kts)
    ReadFloat (&stallspeed, stream);
    rc = TAG_READ;
    break;
  case 'blst':
    ReadFloat (&blst, stream);
    rc = TAG_READ;
    break;
  case 'wTrb':
    // Wing turbulence data
    ReadFloat (&wTrbSpeed, stream);   // Speed
    ReadFloat (&wTrbTimK, stream);    // Time constant
    ReadFloat (&wTrbCeiling, stream); // Ceiling ft MSL
    ReadFloat (&wTrbDuration, stream);  // Duration sec
    rc = TAG_READ;
    break;
  case 'nTrb':
    // ??? turbulence data
    ReadFloat (&nTrbSpeed, stream);   // Speed
    ReadFloat (&nTrbTimK, stream);    // Time constant
    ReadFloat (&nTrbCeiling, stream); // Ceiling ft MSL
    ReadFloat (&nTrbDuration, stream);  // Duration sec
    rc = TAG_READ;
    break;
  case 'dieh':
    // Diehedral Effect Table
    SkipObject (stream);
    rc = TAG_READ;
    break;
  case 'pitd':
    // Pitch moment table
    SkipObject (stream);
    rc = TAG_READ;
    break;
  case 'acrd':
    // Rudder deflection vs. bank angle
    SkipObject (stream);
    rc = TAG_READ;
    break;
  case 'sfxd':
    // Sound effects
    ReadTag (&sfxdTag, stream);
    ReadString (sfxdFilename, 64, stream);
    rc = TAG_READ;
    break;
  case 'mAlt':
    // Status bar display : Altitude message
    ReadMessage (&mAlt, stream);
    rc = TAG_READ;
    break;
  case 'mSpd':
    // Status bar display : Airspeed message
    ReadMessage (&mSpd, stream);
    rc = TAG_READ;
    break;
  case 'mVsi':
    // Status bar display : Vertical speed message
    ReadMessage (&mVsi, stream);
    rc = TAG_READ;
    break;
  case 'mMag':
    // Status bar display : Magnetic compass heading message
    ReadMessage (&mMag, stream);
    rc = TAG_READ;
    break;
  case 'mRpm':
    // Status bar display : Engine RPM
    ReadMessage (&mRpm, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CSimulatedVehicle::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CSimulatedVehicle::ReadFinished (void)
{
}

void CSimulatedVehicle::Write (SStream *stream)
{
}


//
// CFuelSystem
//

CFuelSystem::CFuelSystem (const char* gasFilename)
{
  // Initialize data members
  grad = AIRPORT_FUEL_100LL;

  // Populate data members from GAS stream file
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, gasFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}

CFuelSystem::~CFuelSystem (void)
{
  vector<CFuelSubsystem*>::iterator i;
  for (i=fsub.begin(); i!=fsub.end(); i++) delete *i;
}

int CFuelSystem::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'grad':
    // Preferred fuel grade
    {
      char s[64];
      ReadString (s, 64, stream);
      if (stricmp (s, "AVGAS_80") == 0) {
        grad = AIRPORT_FUEL_80;
      } else if (stricmp (s, "AVGAS_100") == 0) {
        grad = AIRPORT_FUEL_100;
      } else if (stricmp (s, "AVGAS_100LL") == 0) {
        grad = AIRPORT_FUEL_100LL;
      } else if (stricmp (s, "AVGAS_115") == 0) {
        grad = AIRPORT_FUEL_115;
      } else if (stricmp (s, "JETA") == 0) {
        grad = AIRPORT_FUEL_JETA;
      } else if (stricmp (s, "JETA1") == 0) {
        grad = AIRPORT_FUEL_JETA1;
      } else if (stricmp (s, "JETA1PLUS") == 0) {
        grad = AIRPORT_FUEL_JETA1PLUS;
      } else if (stricmp (s, "JETB") == 0) {
        grad = AIRPORT_FUEL_JETB;
      } else if (stricmp (s, "AVGAS_JETBPLUS") == 0) {
        grad = AIRPORT_FUEL_JETBPLUS;
      } else if (stricmp (s, "AUTOMOTIVE") == 0) {
        grad = AIRPORT_FUEL_AUTOMOTIVE;
      } else {
        globals->logWarning->Write ("CFuelSystem::Read : Unknown fuel grade %s", s);
      }
    }
    rc = TAG_READ;
    break;

  case 'fsub':
    // Fuel subsystem
    {
      char type_string[64];
      ReadString (type_string, 64, stream);
      Tag type = StringToTag (type_string);

      CFuelSubsystem *f = NULL;

      switch (type) {
      case SUBSYSTEM_FUEL_SUBSYSTEM:
        f = new CFuelSubsystem;
        break;

      case SUBSYSTEM_FUEL_TAP:
        f = new CFuelTap;
        break;

      case SUBSYSTEM_FUEL_CELL:
        f = new CFuelCell;
        break;

      case SUBSYSTEM_FUEL_HEATER:
        f = new CFuelHeater;
        break;

      case SUBSYSTEM_FUEL_MATH:
        f = new CFuelMath;
        break;

      case SUBSYSTEM_FUEL_PUMP:
        f = new CFuelPump;
        break;

      case SUBSYSTEM_FUEL_SOURCE:
        f = new CFuelSource;
        break;

      case SUBSYSTEM_FUEL_TANK:
        f = new CFuelTank;
        break;

      case SUBSYSTEM_ENGINE_FUEL_PUMP:
        f = new CEngineFuelPump;
        break;

      case SUBSYSTEM_FUEL_MANAGEMENT:
        f = new CFuelManagement;
        break;

      case SUBSYSTEM_APU_FUEL_SOURCE:
        f = new CAPUFuelSource;
        break;
      }

      if (f != NULL) {
        // A valid CFuelSubsystem was instantiated, load it
        ReadFrom (f, stream);
        fsub.push_back (f);
        rc = TAG_READ;
      } else {
        globals->logWarning->Write ("CFuelSystem : Unknown fsub type = %s",
          type_string);
      }
    }
    break;
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelSystem::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CFuelSystem::ReadFinished (void)
{
}

void CFuelSystem::Write (SStream *stream)
{
}


//
// AerodynamicModel
//

CAerodynamicModel::CAerodynamicModel (const char* svhFilename)
{
  // Initialize
  dofa.x = dofa.y = dofa.z = 0.0;
  grnd = false;
  geff = 0.0f;
  gAGL = 0.0f;
  cd = 0.0f;

  // Read from stream file
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, svhFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}

int CAerodynamicModel::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'dofa':
    // Vector distance from empty CG to aerodynamic datum (ft)
    ReadVector (&dofa, stream);
    rc = TAG_READ;
    break;
  case 'grnd':
    // Global ground effect enabled
    grnd = true;
    rc = TAG_READ;
    break;
  case 'geff':
    // Global ground effect factor
    ReadFloat (&geff, stream);
    rc = TAG_READ;
    break;
  case 'gAGL':
    // Global ground effect altitude
    ReadFloat (&gAGL, stream);
    rc = TAG_READ;
    break;
  case '+cd+':
    // Global drag coefficient fudge factor
    ReadFloat (&cd, stream);
    rc = TAG_READ;
    break;
  case 'foil':
    // Airfoil
    SkipObject (stream);
    rc = TAG_READ;
    break;
  case 'wing':
    // Wing section
    SkipObject (stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CAerodynamicModel::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CElectricalSystem
//

CElectricalSystem::CElectricalSystem (const char* ampFilename)
{
  // Initialize control subsystem pointers
  pAileron = NULL;
  pElevator = NULL;
  pRudder = NULL;
  pAileronTrim = NULL;
  pElevatorTrim = NULL;
  pRudderTrim = NULL;

  // Read from AMP file stream
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, ampFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}

CElectricalSystem::~CElectricalSystem (void)
{
  vector<CSubsystem*>::iterator i;
  for (i=subs.begin(); i!=subs.end(); i++) {
    CSubsystem *s = *i;
    delete s;
  }
}

int CElectricalSystem::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'subs':
    {
      char tag_string[64];
      ReadString (tag_string, 64, stream);
      Tag type = StringToTag (tag_string);

      CSubsystem *s = NULL;

      switch (type) {
      case SUBSYSTEM_DEPENDENT:
        s = new CDependent;
        break;

      case SUBSYSTEM_ANNOUNCEMENT:
        s = new CAnnouncement;
        break;

      case SUBSYSTEM_GENERIC_MONITOR:
        s = new CGenericMonitor;
        break;

      case SUBSYSTEM_GENERIC_INDICATOR:
        s = new CGenericIndicator;
        break;

      case SUBSYSTEM_HISTORY:
        s = new CHistory;
        break;

      case SUBSYSTEM_PNEUMATIC_PUMP:
        s = new CPneumaticPump;
        break;

      case SUBSYSTEM_EMERGENCY_LOCATOR:
        s = new CEmergencyLocator;
        break;

      case SUBSYSTEM_EXTERIOR_LIGHT:
        s = new CExteriorLight;
        break;

      case SUBSYSTEM_PITOT_HEAT_SWITCH:
        s = new CPitotHeatSwitch;
        break;

      case SUBSYSTEM_STATIC_SOURCE_SWITCH:
        s = new CStaticSourceSwitch;
        break;

      case SUBSYSTEM_ANNUNCIATOR_LIGHT:
        s = new CAnnunciatorLight;
        break;

      case SUBSYSTEM_STALL_WARNING:
        s = new CStallWarning;
        break;

      case SUBSYSTEM_LIGHT_SETTING_STATE:
        s = new CLightSettingState;
        break;

      case SUBSYSTEM_SWITCH_SET:
        s = new CSwitchSet;
        break;

      case SUBSYSTEM_ROTARY_IGNITION_SWITCH:
        s = new CRotaryIgnitionSwitch;
        break;

      case SUBSYSTEM_BATTERY:
        s = new CBattery;
        break;

      case SUBSYSTEM_ALTERNATOR:
        s = new CAlternator;
        break;

      //
      // Gauge subsystems
      //

      case SUBSYSTEM_ALTIMETER:
        s = new CAltimeter;
        break;

      case SUBSYSTEM_VERTICAL_SPEED:
        {
          char *mark1 = new char[32];
          strcpy (mark1, "vsi start");
        s = new CVerticalSpeedIndicator;
          char *mark2 = new char[32];
          strcpy (mark2, "vsi end");
        }
        break;

      case SUBSYSTEM_AIRSPEED:
        s = new CAirspeedIndicator;
        break;

      case SUBSYSTEM_ATTITUDE:
        s = new CAttitudeIndicator;
        break;

      case SUBSYSTEM_DIRECTIONAL_GYRO:
        s = new CDirectionalGyro;
        break;

      case SUBSYSTEM_VACUUM_INDICATOR:
        s = new CVacuumIndicator;
        break;

      case SUBSYSTEM_TURN_COORDINATOR:
        s = new CTurnCoordinator;
        break;

      case SUBSYSTEM_MAGNETIC_COMPASS:
        s = new CMagneticCompass;
        break;

      case SUBSYSTEM_NAVIGATION:
        s = new CNavigation;
        break;

      case SUBSYSTEM_DIGITAL_CLOCK_OAT:
        s = new CDigitalClockOAT;
        break;

      case SUBSYSTEM_KAP140_PANEL:
        s = new CBKKAP140Panel;
        break;

      case SUBSYSTEM_MARKER_PANEL:
        s = new CMarkerPanel;
        break;

      case SUBSYSTEM_AMMETER:
        s = new CAmmeter;
        break;

      //
      // Engine subsystems
      //

      case SUBSYSTEM_TACHOMETER:
        s = new CTachometer;
        break;

      case SUBSYSTEM_OIL_TEMPERATURE:
        s = new COilTemperature;
        break;

      case SUBSYSTEM_OIL_PRESSURE:
        s = new COilPressure;
        break;

      case SUBSYSTEM_EXHAUST_GAS_TEMPERATURE:
        s = new CExhaustGasTemperature;
        break;

      case SUBSYSTEM_MANIFOLD_PRESSURE:
        s = new CManifoldPressure;
        break;

      case SUBSYSTEM_HOBBS_METER:
        s = new CHobbsMeter;
        break;

      case SUBSYSTEM_TACHOMETER_TIMER:
        s = new CTachometerTimer;
        break;

      //
      // Aircraft control subsystems
      //

      case SUBSYSTEM_THROTTLE_CONTROL:
        s = new CThrottleControl;
        break;

      case SUBSYSTEM_MIXTURE_CONTROL:
        s = new CMixtureControl;
        break;

      case SUBSYSTEM_STEERING_CONTROL:
        s = new CSteeringControl;
        break;

      case SUBSYSTEM_FLAP_CONTROL:
        s = new CFlapControl;
        break;

      case SUBSYSTEM_ELEVATOR_CONTROL:
        s = new CElevatorControl;
        if (pElevator == NULL) {
          // Assign to shortcut pointer
          pElevator = (CElevatorControl *)s;
        } else {
          // Multiple control subsystems
          globals->logWarning->Write ("Multiple elevator subsystems defined");
        }
        break;

      case SUBSYSTEM_AILERON_CONTROL:
        s = new CAileronControl;
        if (pAileron == NULL) {
          // Assign to shortcut pointer
          pAileron = (CAileronControl *)s;
        } else {
          // Multiple control subsystems
          globals->logWarning->Write ("Multiple aileron subsystems defined");
        }
        break;

      case SUBSYSTEM_RUDDER_CONTROL:
        s = new CRudderControl;
        if (pRudder == NULL) {
          // Assign to shortcut pointer
          pRudder = (CRudderControl *)s;
        } else {
          // Multiple control subsystems
          globals->logWarning->Write ("Multiple rudder subsystems defined");
        }
        break;

      case SUBSYSTEM_ELEVATOR_TRIM_CONTROL:
        s = new CElevatorTrimControl;
        if (pElevatorTrim == NULL) {
          // Assign to shortcut pointer
          pElevatorTrim = (CElevatorTrimControl *) s;
        } else {
          // Multiple control subsystems
          globals->logWarning->Write ("Multiple elevator trim subsystems defined");
        }
        break;

      case SUBSYSTEM_AILERON_TRIM_CONTROL:
        s = new CAileronTrimControl;
        if (pAileronTrim == NULL) {
          // Assign to shortcut pointer
          pAileronTrim = (CAileronTrimControl *) s;
        } else {
          // Multiple control subsystems
          globals->logWarning->Write ("Multiple aileron trim subsystems defined");
        }
        break;

      case SUBSYSTEM_RUDDER_TRIM_CONTROL:
        s = new CRudderTrimControl;
        if (pRudderTrim == NULL) {
          // Assign to shortcut pointer
          pRudderTrim = (CRudderTrimControl *) s;
        } else {
          // Multiple control subsystems
          globals->logWarning->Write ("Multiple rudder trim subsystems defined");
        }
        break;

      case SUBSYSTEM_BRAKE_CONTROL:
        s = new CBrakeControl;
        break;

      //
      // Radio subsystems
      //

      case SUBSYSTEM_NAV_RADIO:
        s = new CNavRadio;
        break;

      case SUBSYSTEM_RNAV_RADIO:
        s = new CRnavRadio;
        break;

      case SUBSYSTEM_COMM_RADIO:
        s = new CCommRadio;
        break;

      case SUBSYSTEM_TRANSPONDER_RADIO:
        s = new CTransponderRadio;
        break;

      case SUBSYSTEM_ADF_RADIO:
        s = new CADFRadio;
        break;

      case SUBSYSTEM_KLN89_GPS_RADIO:
        s = new CBKKLN89GPSRadio;
        break;

      case SUBSYSTEM_KX155_RADIO:
        s = new CBKKX155Radio;
        break;

      case SUBSYSTEM_KT76_RADIO:
        s = new CBKKT76Radio;
        break;

      case SUBSYSTEM_KAP140_RADIO:
        s = new CBKKAP140Radio;
        break;

      case SUBSYSTEM_AUDIO_PANEL_RADIO:
        s = new CAudioPanelRadio;
        break;

      //
      // Fuel subsystems
      //

      case SUBSYSTEM_FUEL_MATH:
        // Skip 'fMat' subsystem, this has been made obsolete by
        //   fuel subsystem objects in the CFuelManager class but
        //   older aircraft AMP files may still have a subystem defined
        SkipObject (stream);
        rc = TAG_READ;
        break;

        // *
        // * End of actively implemented subsystems
        // *

/*
        case SUBSYSTEM_ON_GROUND_MONITOR:
        {
          // COnGroundMonitor
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ALTITUDE_MONITOR:
        {
          // CAltitudeMonitor
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_SPEED_MONITOR:
        {
          // CSpeedMonitor
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ENGINE_STATUS:
        {
          // CEngineStatus
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_TIME_DELAY:
        {
          // CTimeDelay
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_KEYED_SYSTEM:
        {
          // CKeyedSystem
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_TACHOMETER_V1:
        {
          // CTachometerV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_THROTTLE_CONTROL_V1:
        {
          // CThrottleV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_MIXTURE_CONTROL_V1:
        {
          // CMixtureControlV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_PROPELLER_CONTROL_V1:
        {
          // CPropellerControlV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_PRIME_CONTROL_V1:
        {
          // CPrimeControlV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ENGINE_ANTI_ICE_V1:
        {
          // CEngineAntiIceV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_IDLE_CONTROL_V1:
        {
          // CIdleControlV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ALTIMETER_V1:
        {
          // CAltimeterV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_VERTICAL_SPEED_V1:
        {
          // CVerticalSpeedV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_AIRSPEED_V1:
        {
          // CAirspeedV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ATTITUDE_V1:
        {
          // CAttitudeV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_DIRECTIONAL_GYRO_V1:
        {
          // CDirectionalGyroV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_TURN_COORDINATOR_V1:
        {
          // CTurnCoordinatorV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_AUDIO_PANEL_V1:
        {
          // CAudioPanelV1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_BATTERY:
        {
          // CBattery
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ALTERNATOR:
        {
          // CAlternator
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_AMMETER:
        {
          // CAmmeter
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_STARTER_CONTROL:
        {
          // CStarterControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_MAGNETO_CONTROL:
        {
          // CMagnetoControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_VOLTMETER:
        {
          // CVoltmeter
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_GENERATOR:
        {
          // CGenerator
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_FREQUENCY_METER:
        {
          // CFrequencyMeter
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_INVERTER:
        {
          // CInverter
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ENGINE_GAUGE:
        {
          // CEngineGauge
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_FUEL_GAUGE:
        {
          // CFuelGauge
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_FLAP_CONTROL:
        {
          // CFlapControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_GEAR_CONTROL:
        {
          // CGearControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_NAVIGATION_GAUGE:
        {
          // CNavigationGauge
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_AUDIO_PANEL:
        {
          // CAudioPanel
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_PROPELLER_CONTROL:
        {
          // CPropellerControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_PRIME_CONTROL:
        {
          // CPrimeControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_EXTERIOR_LIGHT:
        {
          // CExteriorLight
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_HIGH_LIFT_CONTROL:
        {
          // CHighLiftControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_FUEL_FLOW_GAUGE:
        {
          // CFuelFlowGauge
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_FUEL_PRESSURE_GAUGE:
        {
          // CFuelPressureGauge
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ANNUNCIATOR_LIGHT:
        {
          // CAnnunciatorLight
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_SUCTION_GAUGE:
        {
          // CSuctionGauge
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_FLAP_GAUGE:
        {
          // CFlapGauge
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_HOBBS_METER:
        {
          // CTachTimer
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_TACH_TIMER:
        {
          // CTachTimer
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ANNUNCIATOR:
        {
          // CAnnunciator
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_EMERGENCY_LOCATOR:
        {
          // CEmergencyLocator
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_PRESSURIZATION:
        {
          // CPressurization
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_N1_TACHOMETER:
        {
          // CN1Tachometer
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_N2_TACHOMETER:
        {
          // CN2Tachometer
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_TORQUE_METER:
        {
          // CTorqueMeter
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_MARKER_PANEL:
        {
          // CMarkerPanel
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_DME_PANEL:
        {
          // CDmePanel
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_DME_PANEL_1:
        {
          // CDmePanel1
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_WEATHER_RADAR:
        {
          // CWeatherRadar
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_SWITCH_SET:
        {
          // CSwitchSet
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_INDICATOR_SET:
        {
          // CIndicatorSet
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_CONTACTOR:
        {
          // CContactor
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_FLASHER:
        {
          // CFlasher
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_FAST_SLOW_METER:
        {
          // CFastSlowMeter
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_CYLINDER_HEAD_TEMP_GAUGE:
        {
          // CCHTGauge
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ITT_GAUGE:
        {
          // CITTGauge
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_MANIFOLD_PRESSURE_GAUGE:
        {
          // CManifoldPressureGauge
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ACCELEROMETER:
        {
          // CAccelerometer
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_TCAS_PANEL:
        {
          // CTCASPanel
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_GEAR_LIGHT:
        {
          // CGearLignt
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ENGINE_ANTI_ICE:
        {
          // CEngineAntiIce
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ROTARY_IGNITION_SWITCH:
        {
          // CRotaryIgnitionSwitch
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_FUEL_PUMP_CONTROL:
        {
          // CFuelPumpControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_PITOT_HEAT_SOURCE_CONTROL:
        {
          // CPitotHeatSourceControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_STATIC_SOURCE_CONTROL:
        {
          // CStaticSourceControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_STALL_WARNING:
        {
          // CStallWarning
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_BRAKE_CONTROL:
        {
          // CBrakeControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_GEAR_WARNING:
        {
          // CGearWarning
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_SYNCHROPHASER:
        {
          // CSynchrophaser
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_SURFACE_DEICE:
        {
          // CSurfaceDeice
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_PROPELLER_DEICE:
        {
          // CPropellerDeice
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_CROSSFEED_CONTROL:
        {
          // CCrossfeedControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_OXYGEN:
        {
          // COxygen
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_STARTER_IGNITER:
        {
          // CStarterIgniter
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_IDLE_CONTROL:
        {
          // CIdleControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ENGINE_MONITOR:
        {
          // CEngineMonitor
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_FIRE_SYSTEM:
        {
          // CFireSystem
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_FUEL_IMBALANCE:
        {
          // CFuelImbalance
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_COWL_FLAP:
        {
          // CCowlFlap
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_WIPER_CONTROL:
        {
          // CWiperControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ELEVATOR_CONTROL:
        {
          // CElevatorControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_AILERON_CONTROL:
        {
          // CAileronControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_RUDDER_CONTROL:
        {
          // CRudderControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_ELEVATOR_TRIM_CONTROL:
        {
          // CElevatorTrimControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_AILERON_TRIM_CONTROL:
        {
          // CAileronTrimControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_RUDDER_TRIM_CONTROL:
        {
          // CRudderTrimControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_AIR_BRAKE_CONTROL:
        {
          // CAirBrakeControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_THRUST_REVERSE_CONTROL:
        {
          // CThrustReverseControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_PERFORMANCE_RESERVE:
        {
          // CPerformanceReserve
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_RUDDER_BIAS:
        {
          // CRudderBias
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_STALL_IDENT:
        {
          // CStallIdent
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_IGNITER_CONTROL:
        {
          // CIgniterControl
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_WING_DEICE:
        {
          // CWingDeice
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;

        case SUBSYSTEM_PNEUMATIC_PUMP:
        {
          // CPneumaticPump
          SkipObject (stream);
          rc = TAG_READ;
        }
        break;
*/
        default:
          // Skip over unimplemented <subs> types
          SkipObject (stream);
          globals->logWarning->Write ("CElectricalSystem::Read : Skipping object %s",
                tag_string);
          rc = TAG_READ;

      } // switch(type)

      // If a subsystem was instantiated, then load it and add it to the list
      if (s != NULL) {
        ReadFrom (s, stream);
        subs.push_back (s);
//        subs.addEntity (s);
        rc = TAG_READ;
      }

      break;

    } // case 'subs'
  } // switch(tag)

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CElectricalSystem::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CElectricalSystem::ReadFinished (void)
{
  // Check for missing dependents
}

void CElectricalSystem::Write (SStream *stream)
{
}

/*

  Dependent priority graph

  All valid subsystems are of class CDependent or some derivative, so all
  subsystems can be ordered into a directed graph of dependencies.  When
  a subsystem is timesliced, all of its dependencies must already have been
  timesliced.  This is accomplished efficiently by creating an ordered
  graph and ensuring that all dependencies are timesliced first.

  This can also be implemented in the Timeslice methods of the dependencies
  by calling each dependency's Timeslice method before evaluating them.
  State in the dependent subsystem determine whether it has already been
  evaluated on this cycle, or is in the process of being evaluated.

  In the default Flyhawk, there are 130 subsystems and 109 dependencies.
  This suggests that a list of directed edges would be more storage-efficient
  than an adjacency matrix.

*/

/*
void CElectricalSystem::Prepare (void)
{
  int i;

  // TEMP : Determine number of subsystems and number of dependencies
  int nSubs = subs.getNumEntities ();
  int dependencies = 0;
  for (i=0; i < nSubs; i++) {
    CSubsystem *s = (CSubsystem *)subs.getEntity (i);
    if (!s->IsType (SUBSYSTEM_BASE)) {
      CDependent *d = (CDependent *)s;
      dependencies += d->NumDependencies ();
    }
  }

  // Sort subsystems in priority order for timeslicing
  for (i=0; i < subs.getNumEntities(); i++) {
    CSubsystem *s = (CSubsystem *)subs.getEntity (i);

    //
  }
}
*/

void CElectricalSystem::Timeslice (float dT)
{
  // Intialize evaluation state for all dependents
  vector<CSubsystem*>::iterator i;
  for (i=subs.begin(); i!=subs.end(); i++) {
    CSubsystem *s = *i;
    if (!s->IsType (SUBSYSTEM_BASE)) {
      CDependent *d = (CDependent *)s;
      d->SetEvaluated (EVAL_UNKNOWN);
    }
  }

  // Timeslice each electrical subsystem
  for (i=subs.begin(); i!=subs.end(); i++) {
    CSubsystem *s = *i;
    s->TimeSlice (dT);
  }
}


void CElectricalSystem::Print (FILE *f)
{
  fprintf (f, "Electrical System:\n\n");

  // Print each electrical subsystem
  vector<CSubsystem*>::iterator i;
  for (i=subs.begin(); i!=subs.end(); i++) {
    CSubsystem *s = *i;
    fprintf (f, "---------------------------------------------------------------------\n");
    s->Print (f);
    fprintf (f, "\n");
  }
}


/*
 * CPitotStaticSystem
 */

CPitotStaticSystem::CPitotStaticSystem (const char* pssFilename)
{
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, pssFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}

CPitotStaticSystem::~CPitotStaticSystem (void)
{
  vector<CPitotStaticPort*>::iterator i;
  for (i=ports.begin(); i!=ports.end(); i++) delete *i;
}

int CPitotStaticSystem::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'iceT':
    // Ice condition duration
    ReadFloat (&iceT, stream);
    rc = TAG_READ;
    break;

  case 'port':
    // Port sub-object instance
    {
      CPitotStaticPort *port = new CPitotStaticPort;
      ReadFrom (port, stream);
      ports.push_back (port);
//      ports.addEntity (port);
      rc = TAG_READ;
    }
    break;
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CPitotStaticSystem::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CPitotStaticSystem::ReadFinished (void)
{

}


void CPitotStaticSystem::Write (SStream *stream)
{

}

/*
 * CGroundSuspension
 */

CGroundSuspension::CGroundSuspension (const char* whlFilename)
{
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, whlFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}


int CGroundSuspension::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CGroundSuspension::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CGroundSuspension::ReadFinished (void)
{

}


void CGroundSuspension::Write (SStream *stream)
{

}


//
// Loadout Unit
//
CLoadoutUnit::CLoadoutUnit (void)
{
  strcpy (name, "");
  bPos.x = 0;   bPos.y = 0;   bPos.z = 0;
  load = 0;
  hiLm = 0;
  strcpy (utyp, "");
}

int CLoadoutUnit::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'name':
    // Name of loadout position
    ReadString (name, 64, stream);
    rc = TAG_READ;
    break;

  case 'bPos':
    // Offset from default center of gravity
    ReadVector (&bPos, stream);
    rc = TAG_READ;
    break;

  case 'load':
    // Default load value in pounds
    ReadFloat (&load, stream);
    rc = TAG_READ;
    break;

  case 'hiLm':
    // Maximum load value in pounds
    ReadFloat (&hiLm, stream);
    rc = TAG_READ;
    break;

  case 'utyp':
    // UI type
    ReadString (utyp, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CLoadoutUnit::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CLoadoutUnit::ReadFinished (void)
{

}


void CLoadoutUnit::Write (SStream *stream)
{

}


//
// Variable Loadouts
//
CVariableLoadouts::CVariableLoadouts (const char* vldFilename)
{
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, vldFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}

CVariableLoadouts::~CVariableLoadouts(void)
{
  vector<CLoadoutUnit*>::iterator i;
  for (i=unit.begin(); i!=unit.end(); i++) delete *i;
}

int CVariableLoadouts::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'unit':
    {
      // Loadout instance
      CLoadoutUnit *newUnit = new CLoadoutUnit;
      ReadFrom (newUnit, stream);
      unit.push_back (newUnit);
//      unit.addEntity (newUnit);
    }
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CVariableLoadouts::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CVariableLoadouts::ReadFinished (void)
{

}


void CVariableLoadouts::Write (SStream *stream)
{

}


//
// Cockpit Manager
//
CCockpitManager::CCockpitManager (const char* pitFilename)
{
  // Initialize data members
  pPanel = NULL;

  // Read cockpit manager stream
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, pitFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}

CCockpitManager::~CCockpitManager (void)
{
  map<Tag,CPanel*>::iterator i;
  for (i=ckpt.begin(); i!=ckpt.end(); i++) {
    delete i->second;
  }
}

int CCockpitManager::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'ckmg':
    // Cockpit manager sub-object
    rc = TAG_READ;
    break;

  case 'bgno':
  case 'endo':
    // Ignore open and close of cockpit manager sub-object
    rc = TAG_READ;
    break;

  case 'ckpt':
    {
      // Another panel instance
      Tag panelId;
      ReadTag (&panelId, stream);
      char filename[64];
      ReadString (filename, 64, stream);

      // Check for duplicate panel tags
      map<Tag,CPanel*>::iterator i = ckpt.find(panelId);
      if (i==ckpt.end()) {
        // This is a unique panel tag, load it and add to the cockpit panel map
        char *mark3 = new char[32];
        strcpy (mark3, "panel start");
        CPanel* panel = new CPanel (panelId, filename);
        char *mark4 = new char[32];
        strcpy (mark4, "panel end");
        ckpt[panelId] = panel;
      } else {
        // Duplicate panel tag
        gtfo ("CCockpitManager : Duplicate panel tag : 0x%08X", panelId);
      }
    }
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CCockpitManager::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CCockpitManager::ReadFinished ()
{
}


CPanel* CCockpitManager::GetCurrentPanel (void)
{
  return pPanel;
}


void CCockpitManager::SetPanel (Tag tag)
{
  // Deactivate current panel
  if (pPanel != NULL) {
    pPanel->Deactivate ();
  }

  // Search for the supplied tag in the panel map
  map<Tag,CPanel*>::iterator i = ckpt.find(tag);
  if (i!=ckpt.end()) pPanel = i->second;

  // Activate new panel
  if (pPanel != NULL) {
    pPanel->Activate ();
  }
}


Tag CCockpitManager::GetPanel (void)
{
  Tag rc = 0;

  if (pPanel != NULL) {
    rc = pPanel->GetId ();
  }

  return rc;
}


void CCockpitManager::Draw (void)
{
  if (pPanel != NULL) {
    // Draw active panel
    pPanel->Draw ();
  }
}


//
// Camera Manager
//
CCameraManager::CCameraManager (const char* camFilename)
{
  // Default camera is external spot, unless overridden in a Read() call
  defaultCamera = CAMERA_SPOT;

  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, camFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  } else {
    globals->logWarning->Write ("CCameraManager : Cannot open .CAM file %s", camFilename);
  }
}

CCameraManager::~CCameraManager (void)
{
  vector<CCamera*>::iterator i;
  for (i=came.begin(); i!=came.end(); i++) delete *i;
}

int CCameraManager::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'came':
    // Camera definition
    {
      Tag type;
      ReadTag (&type, stream);
      switch (type) {
      case CAMERA_COCKPIT:
        // Cockpit camera
        {
          CCameraCockpit *cock = new CCameraCockpit;
          ReadFrom (cock, stream);
          came.push_back(cock);

          // If a cockpit camera is defined, make it the default
          defaultCamera = CAMERA_COCKPIT;
        }
        break;

      default:
        char s[16];
        TagToString (s, type);
        globals->logWarning->Write ("CCameraManager::Read : Unknown camera type %s", s);
      }
    }
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CCameraManager::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CCameraManager::ReadFinished (void)
{
  // Add other default cameras
  CCameraSpot *spot = new CCameraSpot;
  came.push_back (spot);

  CCameraFlyby *flyby = new CCameraFlyby;
  came.push_back (flyby);

  CCameraObserver *observer = new CCameraObserver;
  came.push_back (observer);

  CCameraTower *tower = new CCameraTower;
  came.push_back (tower);

  CCameraOverhead *over = new CCameraOverhead;
  came.push_back (over);

  // Set default camera
  SelectCamera (defaultCamera);
}

void CCameraManager::UpdateCamera (SPosition *targetPosition, SVector *targetOrientation,
                                   SPosition *eyePosition, SVector *eyeOrientation,
                                   const float dT)
{
  // Get updated eye position from the active camera
  CCamera *cam = *iActive;
  cam->UpdateCamera (targetPosition, targetOrientation,
                     eyePosition, eyeOrientation, dT);

  // Store target and eye positions for Print() method
  tgtPos = *targetPosition;
  tgtOrient = *targetOrientation;
  eyePos = *eyePosition;
  eyeOrient = *eyeOrientation;
}

inline CCamera* CCameraManager::GetActiveCamera (void)
{
  return *iActive;
}

void CCameraManager::ActivateCamera (void)
{
  if (*iActive != NULL) {
    // Notify user of new camera name
    char name[64];
    (*iActive)->GetCameraName (name, 64);
    DrawNoticeToUser (name, 5);
  } else {
    gtfo ("CCameraManager::ActivateCamera : No valid active camera");
  }
}


void CCameraManager::SelectCamera (Tag id)
{
  // Search camera list for the given tag
  int count = 0;
  vector<CCamera*>::iterator i;
  for (i=came.begin(); i!=came.end(); i++, count++) {
    if ((*i)->GetCameraType() == id) {
      iActive = i;
      ActivateCamera ();
    }
  }
}

void CCameraManager::NextCamera (void)
{
  if (iActive == came.begin()) {
    // Wrap around to end of camera list
    iActive = came.end();
  }
  iActive--;

  ActivateCamera ();
}

void CCameraManager::PrevCamera (void)
{
  iActive++;
  if (iActive == came.end()) {
    // Wrap around to beginning of camera list
    iActive = came.begin();
  }

  ActivateCamera ();
}

void CCameraManager::Print (FILE *f)
{
  char debug[256];

  fprintf (f, "Camera Manager:\n\n");

  // Current camera attributes
  CCamera* camera = GetActiveCamera();
  Tag tag = camera->GetCameraType ();
  char sTag[8];
  TagToString (sTag, tag);
  char name[80];
  camera->GetCameraName (name, 80);
  SVector offset;
  camera->GetCameraOffset (&offset);

  fprintf (f, "Current Camera : '%4s' %s\n", sTag, name);
  fprintf (f, "  Offset : x=%6.3f  y=%6.3f  z=%6.3f\n",
    offset.x, offset.y, offset.z);
  fprintf (f, "\n");

  // Eye position
  fprintf (f, "Eye:\n");
  FormatPosition (eyePos, debug);
  fprintf (f, "  Pos  %-40s\n", debug);
  SVector v = PosToScaledFlatCartesianQgt (eyePos);
//  float scale = TerrainScale (eyePos);
//  v.x *= scale;
//  v.y *= scale;
  fprintf (f, "  x = %12.6f  y = %12.6f  z = %12.6f\n", v.x, v.y, v.z);
  fprintf (f, "\n");

  // Eye orientation
  fprintf (f, "Orientation :\n");
  fprintf (f, "       Heading       Pitch       Roll\n");
  fprintf (f, "  Rad   %6.3f       %6.3f       %6.3f\n",
    eyeOrient.h, eyeOrient.p, eyeOrient.r);
  fprintf (f, "  Deg   %6.3f       %6.3f       %6.3f\n",
    RadToDeg (eyeOrient.h), RadToDeg (eyeOrient.p), RadToDeg (eyeOrient.r));
  fprintf (f, "\n");

  // Target position
  fprintf (f, "Target:\n");
  FormatPosition (tgtPos, debug);
  fprintf (f, "  Pos  %-40s\n", debug);
  v = PosToScaledFlatCartesianQgt (tgtPos);
//  scale = TerrainScale (eyePos);
//  v.x *= scale;
//  v.y *= scale;
  fprintf (f, "  x = %12.6f  y = %12.6f  z = %12.6f\n", v.x, v.y, v.z);
  fprintf (f, "\n");

  // Eye orientation
  fprintf (f, "Orientation :\n");
  fprintf (f, "       Heading       Pitch       Roll\n");
  fprintf (f, "  Rad   %6.3f       %6.3f       %6.3f\n",
    tgtOrient.h, tgtOrient.p, tgtOrient.r);
  fprintf (f, "  Deg   %6.3f       %6.3f       %6.3f\n",
    RadToDeg (tgtOrient.h), RadToDeg (tgtOrient.p), RadToDeg (tgtOrient.r));
  fprintf (f, "\n");
}


/*
 * CLevelOfDetail
 */

CLevelOfDetail::CLevelOfDetail (const char* lodFilename)
{
  daynight = new ssgSelector (2);
  daynight->setName ("day_night");

  day = new ssgSelector ();
  day->setName ("day");
  
  night = new ssgSelector ();
  night->setName ("night");

  daynight->addKid (day);
  daynight->addKid (night);

  shadowAcm = NULL;

  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, lodFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}

CLevelOfDetail::~CLevelOfDetail (void)
{
//  daynight->removeAllKids();
//  delete daynight;
  vector<CModelACM*>::iterator i;
  for (i=modelAcm.begin(); i!=modelAcm.end(); i++) delete *i;
//  if (modelAcm != NULL) delete modelAcm;
  if (shadowAcm != NULL) delete shadowAcm;
}

int CLevelOfDetail::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  static bool dayTag = false;     // true when day models tag has been read
  static bool nightTag = false;   // true when night models tag has been read
  static bool dayModels = false;    // true when day models sub-object active
  static bool nightModels = false;  // true when night models sub-object active

  switch (tag) {
  case 'dlod':
    // Daytime models.  This tag introduces a sub-object containing the
    //   various level of detail models for the daytime exterior
    dayTag = true;
    rc = TAG_READ;
    break;

  case 'nlod':
    // Nighttime models.  This tag introduces a sub-object containing the
    //   various level of detail models for the nighttime exterior
    nightTag = true;
    rc = TAG_READ;
    break;

  case 'bgno':
    if (dayTag) {
      // We are expecting this tag to open the day models sub-object
      dayTag = false;
      dayModels = true;
      rc = TAG_READ;
    } else if (nightTag) {
      // We are expecting this <bgno> to open the night models sub-object
      nightTag = false;
      nightModels = true;
      rc = TAG_READ;
    }
    break;

  case 'endo':
    // Signals the end of either the day or night models subobject
    if (dayModels) {
      // This <endo> closes the day models sub-object
      dayModels = false;
      rc = TAG_READ;
    } else if (nightModels) {
      // This <endo> closes the night models sub-object
      nightModels = false;
      rc = TAG_READ;
    } else {
      // We were not processing either the day or night models sub-object,
      //   so we shouldn't have read this <endo>
      globals->logWarning->Write ("CLevelOfDetail::Read : Premature <endo>");
    }
    break;

  case 'mod2':
    {
      // Model specification
      char type[64];
      ReadString (type, 64, stream);
      Tag typeTag = StringToTag (type);

      char filename[64];
      ReadString (filename, 64, stream);
      char fullname[64];
      strcpy (fullname, "Models\\");
      strcat (fullname, filename);

      // Load the model, which will be either a 'comp' (complex) ACM model
      //   or a 'simp' (simple) SMF model
      switch (typeTag) {
      case 'comp':
        {
          CModelACM *tempAcm = new CModelACM (fullname);
          modelAcm.push_back (tempAcm);
          day->addKid (tempAcm->GetSSGEntity());
        }
        break;
      }

      // Level of detail threshold (pixels)
      unsigned int lod;
      ReadUInt (&lod, stream);

      rc = TAG_READ;
    }
    break;

  case 'shad':
    {
      // Low-detail shadow model
      char type[64];
      ReadString (type, 64, stream);
      Tag typeTag = StringToTag (type);

      char filename[64];
      ReadString (filename, 64, stream);

      // Load the model, which will be either a 'comp' (complex) ACM model
      //   or a 'simp' (simple) SMF model
      switch (typeTag) {
      case 'comp':
        shadowAcm = new CModelACM (filename);
        day->addKid (shadowAcm->GetSSGEntity());
        break;
      }

      rc = TAG_READ;
    }
    break;
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CLevelOfDetail::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


ssgEntity *CLevelOfDetail::GetSSGEntity (void)
{
  return daynight;
}


/*
 * CRadioManager
 */

CRadioManager::CRadioManager (const char* rdoFilename)
{
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, rdoFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}


// *
// * The Radio Manager provides a mapping between radio subsystems and the
// *   API functions GetRadio... ???
// *


int CRadioManager::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'rdio':
    {
      char type_string[64];
      ReadString (type_string, 64, stream);
      Tag type = StringToTag (type_string);

//      CSubsystem *s = NULL;
      switch (type) {

      case SUBSYSTEM_NAV_RADIO:
//        s = new CNavRadio;
        break;

      case SUBSYSTEM_RNAV_RADIO:
//        s = new CRnavRadio;
        break;

      case SUBSYSTEM_COMM_RADIO:
//        s = new CCommRadio;
        break;

      case SUBSYSTEM_TRANSPONDER_RADIO:
//        s = new CTransponderRadio;
        break;

      case SUBSYSTEM_ADF_RADIO:
//        s = new CADFRadio;
        break;

      case SUBSYSTEM_KLN89_GPS_RADIO:
//        s = new CBKKLN89GPSRadio;
        break;

      case SUBSYSTEM_KX155_RADIO:
//        s = new CBKKX155Radio;
        break;

      case SUBSYSTEM_KT76_RADIO:
//        s = new CBKKT76Radio;
        break;

      case SUBSYSTEM_KAP140_RADIO:
//        s = new CBKKAP140Radio;
        break;

      case SUBSYSTEM_AUDIO_PANEL_RADIO:
//        s = new CAudioPanelRadio;
        break;

      default:
        globals->logWarning->Write ("CRadioManager : Unknown radio type %s",
          type_string);
      }

      unsigned int group;
      ReadUInt (&group, stream);
      rc = TAG_READ;

//      if (s != NULL) {
//        s->SetGroup (group);
//      }
    }
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CRadioManager::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}



/*
 * CExternalLights
 */

CExternalLights::CExternalLights (const char* eltFilename)
{
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, eltFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}


int CExternalLights::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;


  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CExternalLights::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CExternalLights::ReadFinished (void)
{

}


void CExternalLights::Write (SStream *stream)
{

}


/*
 * CEngineManager
 */

CEngineManager::CEngineManager (const char* ngnFilename)
{
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, ngnFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}


int CEngineManager::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;


  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CEngineManager::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CEngineManager::ReadFinished (void)
{

}


void CEngineManager::Write (SStream *stream)
{

}


/*
 * CControlMixer
 */

CControlMixer::CControlMixer (const char* mixFilename)
{
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, mixFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}


int CControlMixer::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;


  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CControlMixer::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CControlMixer::ReadFinished (void)
{

}


void CControlMixer::Write (SStream *stream)
{

}


/*
 * CChecklists
 */

CChecklists::CChecklists (const char* cklFilename)
{
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, cklFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}


int CChecklists::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;


  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CChecklists::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CChecklists::ReadFinished (void)
{

}


void CChecklists::Write (SStream *stream)
{

}


/*
 * CFlightControlSystem
 */

CFlightControlSystem::CFlightControlSystem (const char* fcsFilename)
{
  SStream s;
  strcpy (s.filename, "World\\");
  strcat (s.filename, fcsFilename);
  strcpy (s.mode, "r");
  if (OpenStream (&s)) {
    ReadFrom (this, &s);
    CloseStream (&s);
  }
}


int CFlightControlSystem::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;


  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlightControlSystem::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CFlightControlSystem::ReadFinished (void)
{

}


void CFlightControlSystem::Write (SStream *stream)
{

}


//
// Slope Wind Data
//
CSlopeWindData::CSlopeWindData (const char* swdFilename)
{

}

int CSlopeWindData::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CSlopeWindData::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CSlopeWindData::ReadFinished (void)
{

}


void CSlopeWindData::Write (SStream *stream)
{

}

Documentation generated by