src/vamos/body/Car.cc

Go to the documentation of this file.

//  Car.cc - a body with wheels.
//
//  Copyright (C) 2001--2004 Sam Varner
//
//  This file is part of Vamos Automotive Simulator.
//
//  This program 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.
//
//  This program 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 this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#include <vamos/body/Aerodynamic_Device.h>
#include <vamos/body/Brake.h>
#include <vamos/body/Car.h>
#include <vamos/body/Clutch.h>
#include <vamos/body/Differential.h>
#include <vamos/body/Engine.h>
#include <vamos/body/Fuel_Tank.h>
#include <vamos/body/Gauge.h>
#include <vamos/body/Particle.h>
#include <vamos/body/Suspension.h>
#include <vamos/body/Tire.h>
#include <vamos/body/Transmission.h>
#include <vamos/body/Wheel.h>

#include <cassert>
#include <sstream>
#include <iostream>

using namespace Vamos_Geometry;

//* Class Key_Control
// The Key_Control class handles gradual application of a control
// that's operated by a button, such as the clutch.  If you're using a
// keyboard instead of a joystick, it also handles steering, gas and
// brake.

//** Constructor
Vamos_Body::Key_Control::
Key_Control (bool block) :
  m_block (block),
  m_target_pending (false),
  m_value (0.0),
  m_target (0.0),
  m_next_target (0.0),
  m_rate (0.0),
  m_next_rate (0.0),
  m_delay (0.0),
  m_next_delay (0.0),
  m_time (0.0),
  m_next_time (0.0)
{
}

// Set the target setting of this control.  NEW_TARGET is the desired
// setting.  TIME is how long it should take for the setting to go
// from 0.0 to 1.0 after waiting for DELAY.  `m_rate' is calculated in
// this function.
void Vamos_Body::
Key_Control::target (double new_target, double time, double delay)
{
  if (m_block)
    {
      if (m_value == m_target)
        {
          m_target_pending = false;
        }
      else
        {
          m_target_pending = true;
          m_next_target = new_target;
          m_next_time = time;
          m_next_delay = delay;
          return;
        }
    }

  m_target = new_target;
  m_delay = delay;
  m_time = 0.0;

  if (time != 0.0)
    {
      m_rate = 1.0 / time;
      if (m_target < m_value)
        {
          m_rate = -m_rate;
        }
    }
  else
    {
      // m_rate == 0.0 means that the value will be immediately set to the
      // target.
      m_rate = 0.0;
    }
}

// Update the setting of this control.  The setting move toward
// `m_target' by the ammount `m_rate' * TIME.
double Vamos_Body::
Key_Control::update (double time)
{
  m_time += time;
  if (m_time < m_delay)
    {
      return m_value;
    }

  if (m_rate == 0.0)
    {
      m_value = m_target;
    }
  else
    {
      m_value += m_rate * time;
      if (((m_rate > 0.0) && (m_value > m_target))
          || ((m_rate < 0.0) && (m_value < m_target)))
        {
          m_value = m_target;
          m_rate = 0.0;
        }
    }

  if (m_target_pending && (m_value == m_target))
    {
      target (m_next_target, m_next_time, m_next_delay);
    }

  return m_value;
}

// Go immediately to the target.
void Vamos_Body::
Key_Control::end ()
{
  m_value = m_target;
  m_time = m_delay;
  m_rate = 0.0;
}



//* Class Car

//** Constructor
Vamos_Body::
Car::Car (const Three_Vector& pos) :
  m_chassis (pos),
  mp_drivetrain (0),
  mp_fuel_tank (0),
  m_max_steer_angle (15.0),
  m_steer_exponent (1.0),
  m_slide (0.0),
  m_shift_pending (false),
  m_shift_timer (0.0),
  m_shift_delay (0.2),
  m_new_gear (0),
  m_last_gear (0),
  m_clutch_key_control (true),
  mp_front_particle (0),
  m_distance_traveled (0.0),
  m_field_of_view (60.0),
  m_pan_angle (90.0),
  m_show_dashboard_extras (false),
  m_sector(-1)
{
        controller = 0;
        brakesetting = 0;
}

extern bool verbose_output;

//** Destructor
// Only the drivetrain member is deleted here.  The rest are deleted
// when the body deletes the particles. 
Vamos_Body::
Car::~Car ()
{
        if (verbose_output)
                std::cout << "Car deinit" << std::endl;
        
        delete mp_drivetrain;
        delete mp_fuel_tank;
        unsigned int i;
        for( i = 0; i < m_wheels.size(); i++ )
        {
                delete m_wheels[i];
        }
        m_wheels.clear ();
        
        if (verbose_output)
                std::cout << "Car deinit done" << std::endl;
}

void Vamos_Body::
Car::read (std::string data_dir, std::string car_file)
{
        unsigned int i;
        
  // Remember the file name for re-reading.
  if ((data_dir != "") && (car_file != ""))
    {
      m_data_dir = data_dir;
      m_car_file = car_file;
    }

        for( i = 0; i < m_wheels.size(); i++ )
        {
                delete m_wheels[i];
        }
        m_wheels.clear ();
        
        for (std::vector <Particle*>::iterator it = m_chassis.particles ().begin ();
        it != m_chassis.particles ().end (); it++)
        delete *it;
        
        m_chassis.particles ().clear ();

/*      if (USE_XML)
                Car_Reader reader (m_data_dir, "cars/" + m_car_file + "/" + m_car_file + ".xml", this);
*/      if (USE_CAR)
        {
                bool success = LoadCarDefinition (m_data_dir + "cars/" + m_car_file + "/" + m_car_file + ".car");
                if (!success)
                {
                        cout << "Error when loading car definition file:  " << m_data_dir + "cars/" + m_car_file + "/" + m_car_file + ".car" << endl;
                }
        }

  // Find the bounding box for the particles.
  std::vector <Particle*>::const_iterator it = m_chassis.particles ().begin ();
  m_crash_box.front = (*it)->position ()[0];
  m_crash_box.back = m_crash_box.front;
  m_crash_box.left = (*it)->position ()[1];
  m_crash_box.right = m_crash_box.left;
  m_crash_box.top = (*it)->position ()[2];
  m_crash_box.bottom = m_crash_box.top;

  mp_front_particle = *it;
  for (; it != m_chassis.particles ().end (); it++)
    {
      const Three_Vector& position = (*it)->position ();
      if (position [0] > m_crash_box.front)
        {
          m_crash_box.front = position [0];
          mp_front_particle = *it;
        }
      else if (position [0] < m_crash_box.back)
        {
          m_crash_box.back = position [0];
        }
      if (position [1] > m_crash_box.left)
        {
          m_crash_box.left = position [1];
        }
      else if (position [1] < m_crash_box.right)
        {
          m_crash_box.right = position [1];
        }
      if (position [2] > m_crash_box.top)
        {
          m_crash_box.top = position [2];
        }
      else if (position [2] < m_crash_box.bottom)
        {
          m_crash_box.bottom = position [2];
        }
    }
}

// Advance the car in time by TIME.  This method assumes that the
// first four members of m_particles are the left-front, right-front,
// left-rear, and right-rear wheels, and that the front wheels are
// steered and the rear wheels are driven.  Re-define this virtual
// function if you want to change these conditions.
void Vamos_Body::
Car::propagate (double time)
{
  // Propagate the key controls.
  m_steer_key_control.update (time);
  m_gas_key_control.update (time);
  m_brake_key_control.update (time);
  m_handbrake_key_control.update (time);
  m_clutch_key_control.update (time);
  m_pan_key_control.update (time);

  // Update the transmission.
  assert (mp_drivetrain);
  if (m_shift_pending)
    {
      m_shift_timer += time;
      if (m_shift_timer > m_shift_delay)
        {
          mp_drivetrain->transmission ()->shift (m_new_gear);
          m_shift_pending = false;
        }
    }

  // Update the throttle.
  assert (mp_fuel_tank);
  double gas = m_gas_key_control.value ();

  // Let the engine know if the fuel tank is empty.
  if (mp_fuel_tank->empty ())
    {
      gas = 0.0;
    }
  mp_drivetrain->engine ()->out_of_gas (mp_fuel_tank->empty ());

  // Update the fuel tank.
  mp_fuel_tank->consume (mp_drivetrain->engine ()->fuel_rate () * time);

  m_slide = 0.0;
  double right_wheel_speed = 0.0;
  double left_wheel_speed = 0.0;
        int count = 0;
  for (std::vector <Wheel*>::iterator it = m_wheels.begin ();
       it != m_wheels.end ();
       it++,count++)
    {
      // Steer.
      if ((*it)->steered ())
        {
          (*it)->steer (m_steer_key_control.value ());
        }

      // Apply the brakes.
                brakesetting = m_brake_key_control.value();
                //if (!(*it)->steered())
                {
                        double handbrakesetting = m_handbrake_key_control.value()*(*it)->get_handbrake_multiplier();
                        if (handbrakesetting > brakesetting)
                                brakesetting = handbrakesetting;
                }
        (*it)->brake (brakesetting);
                //cout << count << ": " << brakesetting << endl;
                
      if ((*it)->driven ())
        {
          // Apply the driving torque.
          (*it)->drive_torque (mp_drivetrain->torque ((*it)->side ()));
                        
                        //cout << mp_drivetrain->torque ((*it)->side ()) << endl;

          if ((*it)->side () == RIGHT)
            right_wheel_speed = (*it)->rotational_speed ();
          else if ((*it)->side () == LEFT)
            left_wheel_speed = (*it)->rotational_speed ();
        }

      // Sum the sliding speeds of the tires.
      m_slide += (*it)->slide ();
    }
        
  // Update the drivetrain.
  mp_drivetrain->input (gas,
                        m_clutch_key_control.value (),
                        left_wheel_speed, right_wheel_speed);

  // Propagate the base class.
  /*mp_drivetrain->find_forces ();
  m_chassis.find_forces ();

  mp_drivetrain->propagate (time / 2.0);
  m_chassis.propagate (time / 2.0);

  mp_drivetrain->find_forces ();
  m_chassis.find_forces ();

  mp_drivetrain->rewind ();
  m_chassis.rewind ();

  mp_drivetrain->propagate (time);
  m_chassis.propagate (time);
  
  m_chassis.end_timestep ();
  
  m_distance_traveled += 
    m_chassis.rotate_in (m_chassis.cm_velocity ()) [0] * time;*/
  
  int iterations = 1;
  
  int i;
  for (i = 0; i < iterations; i++)
  {
          m_chassis.find_forces ();
          m_chassis.propagate (time);
          mp_drivetrain->find_forces ();
          mp_drivetrain->propagate (time/(float) iterations);
          m_chassis.end_timestep();
          m_distance_traveled += 
        m_chassis.rotate_in (m_chassis.cm_velocity ()) [0] * (time/(float)iterations);
  }
}

// Change the steering angle to ANGLE with a time constant of TIME.
void Vamos_Body::
Car::steer (double angle, double time)
{
  double steer_sign = (angle < 0.0) ? -1.0 : 1.0;

  // Apply the non-linearity.
  angle = steer_sign * std::pow (std::abs (angle), m_steer_exponent);

  // Set the maximum angle and speed sensitivity.
  double sens = 1.0 
    / (1.0 + 1.0e-4 * m_steer_speed_sensitivity 
       * m_chassis.cm_velocity ().dot (m_chassis.cm_velocity ()));
  angle *= m_max_steer_angle * sens;
  //printf("%f\n", m_max_steer_angle);
  m_steer_key_control.target (angle, time);
}

// Change the throttle to FACTOR with a time constant of TIME.
void Vamos_Body::
Car::gas (double factor, double time)
{
  m_gas_key_control.target (factor, time);
}

// Change the brakes to FACTOR with a time constant of TIME.
void Vamos_Body::
Car::brake (double factor, double time)
{
  m_brake_key_control.target (factor, time);
}

// Change the handbrakes to FACTOR with a time constant of TIME.
void Vamos_Body::
Car::handbrake (double factor, double time)
{
  m_handbrake_key_control.target (factor, time);
}

// Pan the view.
void Vamos_Body::
Car::pan (double factor, double time)
{
  m_pan_key_control.target (factor * m_pan_angle, time / m_pan_angle);
}

// Shift to the next lower gear.  The chosen gear is returned.
int Vamos_Body::
Car::shift_down ()
{
  return shift (mp_drivetrain->transmission ()->gear () - 1);
}

// Shift to the next higher gear.  The chosen gear is returned.
int Vamos_Body::
Car::shift_up ()
{
  return shift (mp_drivetrain->transmission ()->gear () + 1);
}

// Shift to GEAR.  The chosen gear is returned.
int Vamos_Body::
Car::shift (int gear)
{
  // Do the shift if GEAR is accessible.
  if ((gear <= mp_drivetrain->transmission ()->forward_gears ())
      && (-gear <= mp_drivetrain->transmission ()->reverse_gears ()))
  {
    m_shift_pending = true;
    m_shift_timer = 0.0;
    m_last_gear = mp_drivetrain->transmission ()->gear ();
    m_new_gear = gear;
  }
      
  return m_new_gear;
}

void Vamos_Body::
Car::clutch (double factor, double time)
{
  m_clutch_key_control.target (factor, time, 0.0);
}

// Engage the clutch with a time constant of TIME.
void Vamos_Body::
Car::engage_clutch (double time)
{
  // Wait for the shift timer.
  double delay = m_shift_delay - m_shift_timer;
  m_clutch_key_control.target (1.0, time, delay);
}

// Disengage the clutch with a time constant of TIME.
void Vamos_Body::
Car::disengage_clutch (double time)
{
  // Wait for the shift timer.
  double delay = m_shift_delay - m_shift_timer;
  m_clutch_key_control.target (0.0, time, delay);
}

// Return the pointer to the WHEEL_INDEXth wheel.
Vamos_Body::Wheel* Vamos_Body::Car::
wheel (int wheel_index) const
{
  return m_wheels [wheel_index];
}

// Set the front brake bias to BIAS.
void Vamos_Body::
Car::brake_bias (double bias)
{
  if ((bias >= 0.0) || (bias <= 1.0))
    {
      m_front_brake_bias = bias;
    }
}

// Return the position of the viewpont.
Three_Vector Vamos_Body::
Car::view_position () const
{
  //return m_chassis.position () + m_chassis.rotate_out (m_driver_view);
        return m_driver_view;
}

void Vamos_Body::
Car::start_engine ()
{
  mp_drivetrain->engine ()->start ();
  m_clutch_key_control.end ();
}

// Restore the initial conditions and then set the position to
// POSITION and the orientation to ORIENTATION.
void Vamos_Body::Car::
reset (const Three_Vector& position, const Three_Matrix& orientation)
{
  m_chassis.reset (position, orientation);
  private_reset ();
}

// Restore the initial conditions.
void Vamos_Body::Car::
reset ()
{
  m_chassis.reset ();
  private_reset ();
}

// Perform operations common to both reset() methods. 
void Vamos_Body::Car::
private_reset ()
{
  mp_drivetrain->reset ();
  shift (0);
  start_engine ();
}

void Vamos_Body::
Car::drivetrain (Drivetrain* drive)
{
  assert (drive != 0);
  delete mp_drivetrain;
  mp_drivetrain = drive;
}

// Return true if the position is within the crash box.
bool Vamos_Body::
Car::collision (const Three_Vector& position) const
{
  return m_crash_box.within (m_chassis.transform_in (position));
}

// Return true if the position is within the crash box.
bool Vamos_Body::
Car::Crash_Box::within (const Three_Vector& position) const
{
  return (position [0] < front) && (position [0] > back)
    && (position [1] < left) && (position [1] > right)
    && (position [2] < top) && (position [2] > bottom);
}

//* Class Car_Reader

//** Constructor
/*
Vamos_Body::
Car_Reader::Car_Reader (std::string data_dir, 
                        std::string car_file, 
                        Vamos_Body::Car* car) 
  : m_first_model_for_this_wheel (true),
    m_data_dir (data_dir),
    mp_car (car),
    mp_tachometer (0),
    mp_speedometer (0),
    mp_fuel_gauge (0),
    mp_gear_indicator (0),
    mp_steering_wheel (0),
    m_tachometer_type ("dial"),
    m_speedometer_type ("dial"),
    m_fuel_gauge_type ("dial")
{
  read (data_dir + car_file);
}


Vamos_Body::
Car_Reader::~Car_Reader ()
{
  for (std::vector <Model_Info*>::iterator it = m_models.begin ();
       it != m_models.end ();
       it++)
    {
      delete *it;
    }
}


void Vamos_Body::
Car_Reader::on_start_tag (const Vamos_Geometry::XML_Tag& tag)
{
  //  std::cout << "start " << tag.get_label () << std::endl;
  m_tag = tag.get_label ();
  m_path = m_path + '/' + m_tag;

  const Vamos_Geometry::XML_Tag::Attribute_List& 
    attribs = tag.get_attributes ();

  if ((m_path == "/car/exterior-model") || (m_path == "/car/interior-model"))
    {
      m_strings.clear ();
      m_strings.resize (2);
      m_doubles.resize (1);
      m_doubles [0] = 1.0;
      m_vectors.clear ();
      m_vectors.resize (2);
    }
  else if (m_tag == "view")
    {
      m_vectors.clear ();
      m_doubles.clear ();
      m_doubles.resize (4);
    }
  else if (m_tag == "mirror")
    {
      m_vectors.clear ();
      m_doubles.resize (6);
      m_strings.resize (1);
    }
  else if (m_tag == "steering")
    {
      m_doubles.clear ();
      m_doubles.resize (3);
    }
  else if (m_tag == "dashboard")
    {
      m_ints.clear ();
      m_ints.resize (1);
      m_doubles.clear ();
      m_doubles.resize (12);
      m_strings.clear ();
      m_strings.resize (2);
      m_bools.clear ();
      m_bools.resize (1);
      m_vectors.clear ();
      m_vectors.resize (1);
      m_points.clear ();
      ma_mirrors.clear ();
    }
  else if (m_tag == "on-steering-wheel")
    {
      m_bools [0] = true;
    }
  else if (m_tag == "tachometer")
    {
      if (attribs.size () == 0)
        {
          m_tachometer_type = "dial";
        }
      else
        {
          m_tachometer_type = attribs [0].value;
        }
    }
  else if (m_tag == "speedometer")
    {
      if (attribs.size () == 0)
        {
          m_speedometer_type = "dial";
        }
      else
        {
          m_speedometer_type = attribs [0].value;
        }
    }
  else if (m_tag == "fuel-gauge")
    {
      if (attribs.size () == 0)
        {
          m_fuel_gauge_type = "dial";
        }
      else
        {
          m_fuel_gauge_type = attribs [0].value;
        }
    }
  else if (m_tag == "engine")
    {
      m_doubles.clear ();
      m_doubles.resize (13);
      m_vectors.clear ();
      m_strings.clear ();
      m_strings.resize (1);
    }
        else if (m_tag == "torque-curve")
    {
      m_points.clear ();
      m_bools [0] = true;
      std::istringstream is (attribs [0].value.c_str ());
      is >> m_doubles [9];
    }

  else if (m_tag == "clutch")
    {
      m_doubles.clear ();
    }
  else if (m_tag == "transmission")
    {
      m_doubles.clear ();
      m_gears.clear ();
    }
  else if (m_tag == "differential")
    {
      m_doubles.clear ();
    }
  else if (m_tag == "fuel-tank")
    {
      m_doubles.clear ();
      m_vectors.clear ();
    }
  else if (m_tag == "contact-point")
    {
      m_doubles.resize (3);
      m_strings.resize (1);
      m_vectors.clear ();
    }
  else if (m_tag == "particle")
    {
      m_doubles.resize (1);
      m_vectors.clear ();
    }
  else if (m_tag == "drag")
    {
      m_doubles.resize (2);
      m_vectors.clear ();
    }
  else if (m_tag == "wing")
    {
      m_doubles.resize (6);
      m_vectors.clear ();
    }
  else if (m_tag == "wheel")
    {
      if (m_doubles.size () != 23)
        {
          m_doubles.resize (23);
          m_doubles [8] = 0.0;
          m_doubles [20] = 0.0;
          m_long_parameters.resize (11);
          m_trans_parameters.resize (15);
          m_align_parameters.resize (18);
          m_strings.resize (3);
          m_vectors.resize (5);
        }
      m_strings [0] = attribs [0].value;
      m_strings [1] = attribs [1].value;
      m_bools.clear ();
      m_bools.resize (2);
      m_first_model_for_this_wheel = true;
    }
  else if (m_tag == "steered")
    {
      m_bools [0] = true;
    }
  else if (m_tag == "driven")
    {
      m_bools [1] = true;
    }
}

void Vamos_Body::
Car_Reader::on_end_tag (const Vamos_Geometry::XML_Tag& tag)
{
  //  std::cout << "end " << tag.get_label () << std::endl;
  m_tag = tag.get_label ();

  if ((m_path == "/car/exterior-model") 
      && (m_strings [0] != ""))
    {
      mp_car->exterior_model ("cars/" + m_strings [0],
                              m_doubles [0], m_vectors [0], m_vectors [1]);
    }
  else if ((m_path == "/car/interior-model") 
           && (m_strings [0] != ""))
    {
      mp_car->interior_model (m_data_dir + "cars/" + m_strings [0],
                              m_doubles [0], m_vectors [0], m_vectors [1]);
    }
  else if (m_tag == "view")
    {
      mp_car->set_view (m_vectors [0], m_doubles [0], 
                        m_doubles [1], m_doubles [2], m_doubles [3]);
    }
  else if (m_tag == "mirror")
    {
      mp_car->add_rear_view (m_vectors [0], m_doubles [0], m_doubles [1],
                             m_doubles [2], m_doubles [3], 
                             m_doubles [4], m_doubles [5],
                             m_data_dir + "textures/" + m_strings [0]);
    }
  else if (m_tag == "steering")
    {
      mp_car->max_steer_angle (m_doubles [0]);
      //mp_car->max_steer_angle (60.0);
      mp_car->steer_exponent (m_doubles [1]);
      mp_car->steer_speed_sensitivity (m_doubles [2]);
    }
  else if (m_tag == "mirror-frame")
    {
      ma_mirrors.
        push_back (new Facade (m_doubles [0], m_doubles [1],
                               m_doubles [2], m_doubles [3],
                               m_doubles [4],
                               m_data_dir + "textures/" + m_strings [0]));
    }
  else if (m_tag == "tachometer")
    {
      if (m_tachometer_type == "LED")
        {
          mp_tachometer = 
            new LED_Gauge (m_doubles [0], m_doubles [1], m_doubles [2],
                           m_doubles [3], m_ints [0], 
                           m_doubles [4], m_doubles [5],
                           m_data_dir + "textures/" + m_strings [0],
                           m_bools [0]);
          m_bools [0] = false;
        }
      else if (m_tachometer_type == "digital")
        {
          mp_tachometer = 
            new Digital_Gauge (m_doubles [0], m_doubles [1],
                               m_doubles [2], m_doubles [3],
                               m_doubles [4], m_ints [0],
                               m_data_dir + "textures/" + m_strings [0], 
                               m_bools [0]);
          m_bools [0] = false;
        }
      else
        {
          mp_tachometer = new Dial (m_doubles [0], m_doubles [1],
                                    m_doubles [2], m_doubles [3],
                                    m_doubles [4], m_doubles [5],
                                    m_doubles [6], m_doubles [7],
                                    m_data_dir + "textures/" + m_strings [0], 
                                    m_data_dir + "textures/" + m_strings [1]);
        }
    }
  else if (m_tag == "speedometer")
    {
      if (m_speedometer_type == "digital")
        {
          mp_speedometer = 
            new Digital_Gauge (m_doubles [0], m_doubles [1],
                               m_doubles [2], m_doubles [3],
                               m_doubles [4], m_ints [0],
                               m_data_dir + "textures/" + m_strings [0], 
                               m_bools [0]);
          m_bools [0] = false;
        }
      else
        {
          mp_speedometer = new Dial (m_doubles [0], m_doubles [1],
                                     m_doubles [2], m_doubles [3],
                                     m_doubles [4], m_doubles [5],
                                     m_doubles [6], m_doubles [7],
                                     m_data_dir + "textures/" + m_strings [0], 
                                     m_data_dir + "textures/" + m_strings [1]);
        }
    }
  else if (m_tag == "fuel-gauge")
    {
      if (m_fuel_gauge_type == "digital")
        {
          mp_fuel_gauge = 
            new Digital_Gauge (m_doubles [0], m_doubles [1],
                               m_doubles [2], m_doubles [3],
                               m_doubles [4], m_ints [0],
                               m_data_dir + "textures/" + m_strings [0], 
                               m_bools [0]);
          m_bools [0] = false;
        }
      else
        {
          mp_fuel_gauge = new Dial (m_doubles [0], m_doubles [1],
                                    m_doubles [2], m_doubles [3],
                                    m_doubles [4], m_doubles [5],
                                    m_doubles [6], m_doubles [7],
                                    m_data_dir + "textures/" + m_strings [0], 
                                    m_data_dir + "textures/" + m_strings [1]);
        }
    }
  else if (m_tag == "gear-indicator")
    {
      mp_gear_indicator = 
        new Gear_Indicator (m_doubles [0], m_doubles [1],
                            m_doubles [2], m_doubles [3],
                            m_doubles [4], m_ints [0],
                            m_data_dir + "textures/" + m_strings [0],
                            m_bools [0]);
      m_bools [0] = false;
    }
  else if (m_tag == "gear-shift")
    {
      mp_gear_indicator = 
        new Gear_Shift (m_doubles [0], m_doubles [1],
                        m_doubles [2], m_doubles [3],
                        m_doubles [4], m_vectors [0],
                        m_points,
                        m_data_dir + "textures/" + m_strings [0],
                        m_data_dir + "textures/" + m_strings [1]);
    }
  else if (m_tag == "steering-wheel")
    {
      mp_steering_wheel = 
        new Steering_Wheel (m_doubles [0], m_doubles [1],
                            m_doubles [2], m_doubles [3],
                            m_doubles [4], m_doubles [5],
                            m_doubles [6], m_doubles [7],
                            m_data_dir + "textures/" + m_strings [0]);
    }
  else if (m_tag == "dashboard")
    {
      Dashboard* dash = new Dashboard (m_doubles [8], m_doubles [9],
                                       m_doubles [10], m_doubles [11]);
      for (std::vector <Facade*>::iterator it = ma_mirrors.begin ();
           it != ma_mirrors.end ();
           it++)
        {
          dash->add_facade (*it);
        }
      dash->add_tachometer (mp_tachometer);
      dash->add_speedometer (mp_speedometer);
      dash->add_fuel_gauge (mp_fuel_gauge);
      dash->add_gear_indicator (mp_gear_indicator);
      dash->add_steering_wheel (mp_steering_wheel);
      mp_car->dashboard (dash);
    }
  else if (m_path ==  "/car/dashboard/extras")
    {
      mp_car->show_dashboard_extras (true);
    }
  else if (m_tag == "engine")
    {
      mp_engine = new Engine (m_doubles [0], m_vectors [0], m_doubles [1], 
                              m_doubles [2], m_doubles [3], m_doubles [4], 
                              m_doubles [5], m_doubles [6], m_doubles [7],
                              m_doubles [8]);

                if (m_bools [0])
        {
          mp_engine->set_torque_curve (m_points);
          mp_engine->set_friction (m_doubles [9]);
        }

      mp_car->engine_sound (m_data_dir + "sounds/" + m_strings [0], 
                            m_doubles [9], m_doubles [10],
                            m_doubles [11], m_doubles [12]);
    }

   else if (m_tag == "clutch")
    {
      if (m_doubles.size () != 4)
        {
          error ("clutch requires 4 arguments");
        }
      mp_clutch = new Clutch (m_doubles [0], m_doubles [1], m_doubles [2], 
                              m_doubles [3]);
    }

  else if (m_tag == "transmission")
    {
      if (m_doubles.size () == 4)
        {
          mp_transmission = new Transmission (int (m_doubles [0]),
                                              m_doubles [1],
                                              m_doubles [2]);
          mp_car->shift_delay (m_doubles [3]);
        }
      else
        {
          mp_transmission = new Transmission;
          for (std::vector <std::pair <int, double> >::const_iterator 
                 it = m_gears.begin ();
               it != m_gears.end ();
               it++)
            {
              mp_transmission->gear_ratio (it->first, it->second);
            } 
          mp_car->shift_delay (m_doubles [1]);
        }
    }
  
  else if (m_tag == "differential")
    {
      if (m_doubles.size () != 2)
        {
          error ("differential requires 2 arguments");
        }
      mp_differential = new Differential (m_doubles [0], m_doubles [1]);
    }

  else if (m_tag == "drivetrain")
    {
      delete mp_car->mp_drivetrain;
      mp_car->mp_drivetrain = 
        new Drivetrain (mp_engine, mp_clutch, 
                        mp_transmission, mp_differential);
    }

  else if (m_tag == "fuel-tank")
    {
      if ((m_doubles.size () != 3) || (m_vectors.size () != 1))
        {
          error ("fuel tank requires 1 or 3 elements");
        }
      delete mp_car->mp_fuel_tank;
      mp_car->mp_fuel_tank = new Fuel_Tank (m_vectors [0], m_doubles [0],
                                            m_doubles [1], m_doubles [2]);
    }

  else if (m_tag == "car")
    {
      mp_car->chassis ().particles ().
        push_back (mp_car->mp_drivetrain->engine ());
      mp_car->chassis ().particles ().push_back (mp_car->mp_fuel_tank);
    }

  else if (m_tag == "particle")
    {
      mp_car->chassis ().particles ().
        push_back (new Particle (m_doubles [0], m_vectors [0]));
    }
  else if (m_tag == "contact-point")
    {
      Material::Material_Type material = Material::UNKNOWN;
      if (m_strings [0] == "rubber")
        material = Material::RUBBER;
      else if (m_strings [0] == "metal")
        material = Material::METAL;

      mp_car->chassis ().particles ().
        push_back (new Contact_Point (m_doubles [0], m_vectors [0], material,
                                      m_doubles [1], m_doubles [2]));
    }
  else if (m_tag == "drag")
    {
      mp_car->chassis ().particles ().push_back (new Drag (m_vectors [0], 
                                               m_doubles [0], 
                                               m_doubles [1]));
    }
  else if (m_tag == "wing")
    {
      mp_car->chassis ().particles ().
        push_back (new Wing (m_vectors [0], m_doubles [0], 
                             m_doubles [1], m_doubles [2], 
                             m_doubles [3], m_doubles [4]));
    }
  else if (m_path == "/car/wheel/suspension/model")
    {
      if (m_first_model_for_this_wheel)
        {
          m_models.clear ();
          m_first_model_for_this_wheel = false;
        }
      m_models.push_back (new Model_Info (m_strings [2], m_doubles [21],
                                          m_vectors [3], m_vectors [4]));
    }
  else if (m_tag == "wheel")
    {
      Side side = (m_strings [0] == "left") ? LEFT : RIGHT;
      Suspension* suspension =
        new Suspension (m_vectors [1], m_vectors [2], side, m_doubles [0],
                        m_doubles [1], m_doubles [2], m_doubles [3],
                        m_doubles [4]);
      suspension->camber (m_doubles [5]);
      suspension->caster (m_doubles [6]);
      suspension->toe (m_doubles [7]);
      if (m_doubles [8] != 0.0)
        {
          Suspension* other = static_cast <Suspension*> 
            (*(mp_car->chassis ().particles ().end () - 2));
          assert (other != 0);
          suspension->anti_roll (other, m_doubles [8]);
          m_doubles [8] = 0.0;
        }
      for (std::vector <Model_Info*>::iterator it = m_models.begin ();
           it != m_models.end ();
           it++)
        {
          suspension->set_model ("cars/" + (*it)->file,
                                 (*it)->scale, 
                                 (*it)->translate,
                                 (*it)->rotate);
        }
      mp_car->chassis ().particles ().push_back (suspension->hinge ());
      mp_car->chassis ().particles ().push_back (suspension);

      Tire_Friction friction (m_long_parameters, m_trans_parameters,
                              m_align_parameters);
      Tire tire (m_doubles [9], m_doubles [10], m_doubles [11], friction,
                 m_doubles [12]);

      double bias = m_doubles [17];
      if (m_strings [1] == "rear")
          bias = 1.0 - bias;
      Brake brake (m_doubles [13], m_doubles [14], m_doubles [15], 
                   m_doubles [16], bias);
 
      Wheel* wheel = new Wheel (m_doubles [18], m_vectors [0], 
                                m_doubles [22], m_doubles [20], m_doubles [19],
                                suspension, tire, brake,
                                m_bools [0], m_bools [1], side);
      mp_car->chassis ().particles ().push_back (wheel);
      mp_car->m_wheels.push_back (wheel);
      if (m_slow_model != "")
        {
          std::string stator_path;
          if (m_stator_model != "")
            {
              stator_path = m_data_dir + "cars/" + m_stator_model;
            }
                if (m_strings [1] == "rear")
                        {
          wheel->set_models (settings.GetFullDataPath("cars/" + mp_car->m_car_file + "/wheel_rear.joe"),
                             settings.GetFullDataPath("cars/" + mp_car->m_car_file + "/wheel_rear.joe"),
                             m_transition,
                             stator_path, m_stator_offset, 
                             m_scale, m_translation, m_rotation);
                        }
                        else
                        {
                                wheel->set_models (settings.GetFullDataPath("cars/" + mp_car->m_car_file + "/wheel_front.joe"),
                             settings.GetFullDataPath("cars/" + mp_car->m_car_file + "/wheel_front.joe"),
                             m_transition,
                             stator_path, m_stator_offset, 
                             m_scale, m_translation, m_rotation);
                        }
        }
    }

  m_path = m_path.substr (0, m_path.find_last_of ("/"));
}

void Vamos_Body::
Car_Reader::on_data (std::string data_string)
{
  std::string data = remove_leading_space (data_string);
  if (data.size () == 0)
    {
      return;
    }
  std::istringstream is (data.c_str ());

  if (m_path == "/car/dashboard/position")
    {
      char delim;
      is >> delim >> m_doubles [8] >> delim >> m_doubles [9] 
         >> delim >> m_doubles [10];
    }
  else if (m_path == "/car/dashboard/tilt")
    {
      is >> m_doubles [11];
    }
  else if ((m_path == "/car/dashboard/mirror-frame/position")
           || (m_path == "/car/dashboard/tachometer/position")
           || (m_path == "/car/dashboard/speedometer/position")
           || (m_path == "/car/dashboard/fuel-gauge/position")
           || (m_path == "/car/dashboard/gear-indicator/position")
           || (m_path == "/car/dashboard/gear-shift/position")
           || (m_path == "/car/dashboard/steering-wheel/position"))
    {
      char delim;
      is >> delim >> m_doubles [0] >> delim >> m_doubles [1] 
         >> delim >> m_doubles [2];
    }
  else if ((m_path == "/car/dashboard/tachometer/radius")
           || (m_path == "/car/dashboard/tachometer/width")
           || (m_path == "/car/dashboard/speedometer/radius")
           || (m_path == "/car/dashboard/fuel-gauge/radius")
           || (m_path == "/car/dashboard/steering-wheel/radius"))
    {
      is >> m_doubles [3];
    }
  else if (m_path == "/car/dashboard/tachometer/elements")
    {
      is >> m_ints [0];
    }
  else if (m_path == "/car/dashboard/tachometer/range")
    {
      char delim;
      is >> delim >> m_doubles [4] >> delim >> m_doubles [5];
    }
  else if ((m_path == "/car/dashboard/tachometer/min")
           || (m_path == "/car/dashboard/speedometer/min")
           || (m_path == "/car/dashboard/fuel-gauge/min")
           || (m_path == "/car/dashboard/steering-wheel/min"))
    {
      char delim;
      is >> delim >> m_doubles [4] >> delim >> m_doubles [5];
    }
  else if ((m_path == "/car/dashboard/tachometer/max")
           || (m_path == "/car/dashboard/speedometer/max")
           || (m_path == "/car/dashboard/fuel-gauge/max")
           || (m_path == "/car/dashboard/steering-wheel/max"))
    {
      char delim;
      is >> delim >> m_doubles [6] >> delim >> m_doubles [7];
    }
  else if (m_path == "/car/dashboard/gear-shift/rotation")
    {
      is >> m_vectors [0];
    }
  else if (m_path == "/car/dashboard/gear-shift/stick-positions")
    {
      Two_Point point;
      while (is >> point)
        {
          m_points.push_back (point);
        }
    }
  else if ((m_path == "/car/dashboard/mirror-frame/image")
           || (m_path == "/car/dashboard/tachometer/face")
           || (m_path == "/car/dashboard/tachometer/image")
           || (m_path == "/car/dashboard/speedometer/face")
           || (m_path == "/car/dashboard/speedometer/image")
           || (m_path == "/car/dashboard/fuel-gauge/face")
           || (m_path == "/car/dashboard/fuel-gauge/image")
           || (m_path == "/car/dashboard/gear-indicator/image")
           || (m_path == "/car/dashboard/gear-shift/gate")
           || (m_path == "/car/dashboard/steering-wheel/image"))
    {
      is >> m_strings [0];
    }
  else if ((m_path == "/car/dashboard/tachometer/needle")
           || (m_path == "/car/dashboard/speedometer/needle")
           || (m_path == "/car/dashboard/fuel-gauge/needle")
           || (m_path == "/car/dashboard/gear-shift/stick"))
    {
      is >> m_strings [1];
    }
  else if ((m_path == "/car/dashboard/mirror-frame/size")
           || (m_path == "/car/dashboard/gear-indicator/size")
           || (m_path == "/car/dashboard/gear-shift/size")
           || (m_path == "/car/dashboard/tachometer/size")
           || (m_path == "/car/dashboard/speedometer/size")
           || (m_path == "/car/dashboard/fuel-gauge/size"))
    {
      char delim;
      is >> delim >> m_doubles [3] >> delim >> m_doubles [4];
    }
  else if ((m_path == "/car/dashboard/gear-indicator/numbers")
           || (m_path == "/car/dashboard/tachometer/places")
           || (m_path == "/car/dashboard/speedometer/places")
           || (m_path == "/car/dashboard/fuel-gauge/places"))
    {
      is >> m_ints [0];
    }

  // Particle
  else if (m_path == "/car/particle/mass")
    is >> m_doubles [0];

  // Contact Point
  else if (m_path == "/car/contact-point/mass")
    is >> m_doubles [0];
  else if (m_path == "/car/contact-point/material")
    is >> m_strings [0];
  else if (m_path == "/car/contact-point/friction")
    is >> m_doubles [1];
  else if (m_path == "/car/contact-point/restitution")
    is >> m_doubles [2];

  // Drag
  else if (m_path == "/car/drag/frontal-area")
    is >> m_doubles [0];
  else if (m_path == "/car/drag/drag-coefficient")
    is >> m_doubles [1];

  // Wing
  else if (m_path == "/car/wing/frontal-area")
    is >> m_doubles [0];
  else if (m_path == "/car/wing/drag-coefficient")
    is >> m_doubles [1];
  else if (m_path == "/car/wing/surface-area")
    is >> m_doubles [2];