top-down racer handbrake implementation

Hi

   I guess you could do the following:

#define MAX_HANDBRAKE = 256
int handbrakeinc = 0;
int handbrake = 0;

void check_handbrake()
{
  if (space_bar_pressed)
  {
    handbrakeinc++;
    if (hanbrake != MAX_HANDBRAKE)
       handbrake += handbrakeinc;
  }
  else
  {
    handbrakeinc = 0;
    handbrake = 0;
  }
}

The above is only to handle the very basic mechanics of an handbrake. As the user holds down the key more and more handbrake is applied at an accelerated rate. You could then input handbrake into your physics routine and reduce velocity accordingly, throttle could be implemented in a similar manner.

void simple_physics(int ax, int ay, int handbrake)
{
   // Add acceleration onto velocity
   vx += ax;
   vy += ay;
   // Apply handbrake
   if (handbrake != 0)
   {
      vx /= handbrake;
      vy /= handbrake;
   }
   // Add velocity onto position to move car
   x += vx;
   y += vy;
}
vx and vy should be part of your object structure, see later in this message

Ive not tried not of this code so I dont know how well it performs. Dividing the x and y velocities by the amount of handbrake will slow down the car.

Maybe your car structure could look like this

typedef struct {
  int x, y;
  int vx, vy;
  int throttle;
  int brake;
  int handbrake;
} CAR;

In which case the above routines will change to:

void check_handbrake(CAR *car)
{
  if (space_bar_pressed)
  {
    car->handbrakeinc++;
    if (car->handbrake != MAX_HANDBRAKE)
       car->handbrake += handbrakeinc;
  }
  else
  {
    car->handbrakeinc = 0;
    car->handbrake = 0;
  }
}

void simple_physics(CAR *car)
{
   // Apply handbrake
   if (car->handbrake != 0)
   {
      car->vx /= car->handbrake;
      car->vy /= car->handbrake;
   }
   // Add velocity onto position to move car
   car->x += car->vx;
   car->y += car->vy;
}

However since you are using C++ you would be better off implementing all this as a class like so

#define MAX_HANDBRAKE 256
#define MAX_THROTTLE 256

// Fill these with sin and cosine waves, amplitude between -4095 and +4095
int sine[360];
int cose[360];
bool throttle_pressed = false;
bool handbrake_pressed = false;


typedef struct {
  int x, y;
  int vx, vy;
  int angle;
  int brake;
  int throttleinc;
  int throttle;
  int handbrakeinc;
  int handbrake;
} CAR_TYPE;

class CAR
{
private:
      CAR_TYPE      car;
      int                  handbrakeinc;
      int                  handbrake;

public:
      CAR(int x, int y);
private:
      void            apply_handbrake();
      void            apply_throttle();
public:
      void            run(bool apply_throttle, bool apply_handbrake);
      void            set_angle(int ang);
};

CAR::CAR(int x, int y)
{
      car.handbrake = 0;
      car.handbrakeinc = 0;
      car.throttle = 0;
      car.throttleinc = 0;
      car.x = x;
      car.y = y;
      car.vx = 0;
      car.vy = 0;
      car.angle = 0;
}

void CAR::apply_handbrake()
{
      if (handbrake < MAX_HANDBRAKE)
      {
            car.handbrakeinc++;
            car.handbrake += car.handbrakeinc;
      }
      else
            car.handbrake = MAX_HANDBRAKE;
}
void CAR::apply_throttle()
{
      if (handbrake < MAX_THROTTLE)
      {
            car.throttleinc++;
            car.throttle += car.throttleinc;
      }
      else
            car.throttle = MAX_THROTTLE;
}

void CAR::run(bool apply_throt, bool apply_hb)
{
      if (apply_throt)      // Player has foot on throttle
            apply_throttle();
      else                        // Player has taken foot off throttle
      {
            // Decay throttle
            car.throttleinc = 0;
            if (car.throttle > 0)
                  car.throttle--;
            else
                  car.throttle = 0;
      }

      if (apply_hb)      // Player has foot on handbrake
            apply_handbrake();
      else                        // Player has taken foot off handbrake
      {
            // Decay handbrake
            car.handbrakeinc = 0;
            car.handbrake = 0;
      }
      // Acceleration is applied in direction car is travelling
      car.vx = (sine[car.angle] * car.throttle) >> 12;  // >>12 = div by 4096 which is amplitude of sin wave
      car.vy = (cose[car.angle] * car.throttle) >> 12;  // >>12 = div by 4096 which is amplitude of cosine wave

      // Handle brake physics
      if (car.handbrake != 0)
      {
            car.vx /= car.handbrake;
            car.vy /= car.handbrake;
      }

      // Move car
      car.x += car.vx;
      car.y += car.vy;

      // Collision detection
      // .....
      // .....
      // .....
}
void CAR::set_angle(int ang)
{
      car.angle = ang;
}
void main(void)
{
      // Create a car
      CAR mycar(0, 0);

      while(1)
      {
            // Monitor keyboard

            // Run car handler
            mycar.run(throttle_pressed, handbrake_pressed);
      }
}


The above code compiles but I havent tested it and may require messing around with, but it shows the basics of whats happening. Personaly I would implement the physics system using proper physics so later on applying physical effects to the car would be easier to implement. The above method also uses all integer maths, you may want to do it in float, its as fast on a PC if not faster, I would still tabulate sin and cosine though if your gonna have a lot of cars.

DirectX is a whole different ball game and is way out of the realms of this forum, but basically you will use:

DirectInput for monitoring keyboard input
DirectDraw for drawing the cars and scenery
DirectSound for sound effects
DirectMusic for music or just play CD music its easier
Direct3D if you feel adventurous and want the game to run in 3D.


Hope this helps

Matth