toycars/src/CarGame.cpp

/*
	Copyright (C) 2005 by Ruben Henner Zilibowitz <rzilibowitz@users.sourceforge.net>
	Part of the Toy Cars Project http://toycars.sourceforge.net

	This program is free software; you can redistribute it and/or modify
	it under the terms of the license.
	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY.

	See the COPYING file for more details.
*/

/*
 *  Created by Ruben Henner Zilibowitz on 1/01/05.
 */

#include "RobotPlayer.h"
#include "CarGame.h"
#include "GameConstants.h"
#include "Rectangle.h"
#include "ScException.h"
#include "Kaboom.h"
#include "Startline.h"
#include "glf.h"
#include "TcPreferences.h"
#include <cstdlib>
#include "PathLine.h"
#include <cstdio>
#ifndef WIN32
 #include <ctime>
#endif
#include <unistd.h>
#include "SDL.h"
#include "SDL_image.h"
//------------

/* When using MINGW (-mno-cygwin), srandom/random isn't defined */
#ifndef srandom
    #define srandom srand
#endif
#ifndef random
    #define random rand
#endif
#ifndef seed48
unsigned short * seed48(unsigned short xseed[3])
{
	srandom(*((unsigned long*)(xseed+1)));
	return NULL;
}
#endif

#ifndef INFINITY
#define INFINITY 1e20
#endif

const double kWrongWayCheckInterval = 2.0;   // in seconds
const double kWrongWayPosOffset = 1e-3;
const double kSignFadeSpeed = 4.0;
const double kSignScreenPosition = 0.7;   // 1 is top 0 is bottom
const double kWrongWayScreenPosition = 0.6;  // 1 is top 0 is bottom

// defined in main.cpp
void PixelDataForSurface(const SDL_Surface* src, ScPixelData& dst);

void testRand()
{
	int i;
	printf("RAND_MAX: %d\n", RAND_MAX);
	for (i = 0; i < 200; i++)
		printf("%lf ", drand48());
	printf("\n");
}

extern TcPreferences *gPreferences; // the maximum number of particles in the animation at any one time
const int kNumLaps = 4;         // the number of laps to the race

// external functions
void ERRCHECK(FMOD_RESULT result);

// -----------------------------------------------------------------------------
//	CarGame::CarGame
//
//  Constructor. Sets up animation. Inits random number generator.
// -----------------------------------------------------------------------------

CarGame::CarGame(Tileset* inTilemap, Player** inPlayers, int inNumPlayers, FMOD::System* inFMOD_system, Tuple inStartLineA, Tuple inStartLineB, bool inClockwise, const list<Tuple> *inPathPolygon, const list<RoadSignInterval> *inSignIntervals)
	:   tilemap(*inTilemap), players(inPlayers), numPlayers(inNumPlayers),
		particles(new ScParticles(gPreferences->getMaxParticles())),
		runningTime(0.0), startLineA(inStartLineA), startLineB(inStartLineB), lastLight(-1), pathPolygon(inPathPolygon),
		FMOD_System(inFMOD_system), clockwise(inClockwise), signIntervals(inSignIntervals), cameraMode(kRotoZoomingCamera)
{
#if HAVE_FMOD_LIB
    FMOD_RESULT      result;
#endif
	int i;

	// set the game rect
	gameRect.left = 0;
	gameRect.bottom = 0;
	gameRect.right = tilemap.getMapWidth() * tilemap.getTileWidth();
	gameRect.top = tilemap.getMapHeight() * tilemap.getTileHeight();

	// Set up Scoobie animation

	// put the tile map inside the animation
	animation.push_back(inTilemap);
	// put the particles inside the animation
	animation.push_back(particles);
	// create and add start line
	animation.push_back(new Startline(startLineA, startLineB));

	// put the cars inside the top layer
	// and put players into playersInGame list
	// and tell the players about this
	for (i = 0; i < numPlayers; i++)
	{
		animation.push_back(&players[i]->car);
		playersInGame.push_back(players[i]);
		players[i]->setGame(this);
	}

	// load needle image
	needle = new NeedleImage();

	// load label images
	labelKPH = new StaticImage("images/KPH.png");
	labelRPM = new StaticImage("images/RPM.png");

   // load signs sprite
   SDL_Surface *signsImg = IMG_Load("images/signs.png");
   ScPixelData pixData;
   PixelDataForSurface(signsImg, pixData);
   signsSprite = new ScSprite(64,64,0,pixData);
	SDL_FreeSurface(signsImg);

   // compute total path length
   totalPathLength = computeTotalPathLength();

	// load start lights
	for (int k = 0; k < kNumStartLights; k++) {
		lights[k] = new StartLight(k);
	}

	fprintf(stderr, "done all lights\n");

	// the glf library should have already been initialised

	// create and load the minimap
	minimap = new Minimap(tilemap, playersInGame);
	fprintf(stderr, "done minimap\n");
    /*
        Load some sounds
    */

#if HAVE_FMOD_LIB
	if (gPreferences->getSounds()) {
		result = FMOD_System->createSound("sounds/engine.wav", FMOD_SOFTWARE | FMOD_3D, 0, &engineSound);
		ERRCHECK(result);
		result = engineSound->set3DMinMaxDistance(4.0f, 10000.0f);
		ERRCHECK(result);
		result = engineSound->setMode(FMOD_LOOP_NORMAL);
		ERRCHECK(result);

		result = FMOD_System->createSound("sounds/mud.wav", FMOD_SOFTWARE | FMOD_3D, 0, &dustSlideSound);
		ERRCHECK(result);
		result = dustSlideSound->set3DMinMaxDistance(4.0f, 10000.0f);
		ERRCHECK(result);
		result = dustSlideSound->setMode(FMOD_LOOP_NORMAL);
		ERRCHECK(result);

		result = FMOD_System->createSound("sounds/bang_6.wav", FMOD_SOFTWARE | FMOD_3D, 0, &crashSound);
		ERRCHECK(result);
		result = crashSound->set3DMinMaxDistance(4.0f, 10000.0f);
		ERRCHECK(result);
		result = crashSound->setVariations(44.1e2,0.01,0);
		ERRCHECK(result);

		result = FMOD_System->createSound("sounds/organ-c6.aif", FMOD_SOFTWARE, 0, &organC6Sound);
		ERRCHECK(result);

		result = FMOD_System->createSound("sounds/organ-c7.aif", FMOD_SOFTWARE, 0, &organC7Sound);
		ERRCHECK(result);
	}
#endif

	// path line
	//animation.push_back(new PathLine(tilemap.getBounds(), pathPolygon));

	// init seed for random number generator
	unsigned short s[4];
#ifdef WIN32
	s[0] = 1; s[1] = 2; s[2] = 3; s[3] = 4;
#else
	time((time_t*)s);
	*(clock_t*)(s+2) = clock();
#endif
	seed48(s + 1);

	setupStart();

	fprintf(stderr, "done setup\n");
    /*
        Play sounds at certain positions
    */
#if HAVE_FMOD_LIB
	if (gPreferences->getSounds()) {
		for (list<Player*>::iterator i = playersInGame.begin(); i != playersInGame.end(); i++)
		{
			(*i)->setEngineSound(engineSound);
			(*i)->setDustSlideSound(dustSlideSound);
		}
	}
#endif
}

// -----------------------------------------------------------------------------
//	CarGame::setupStart
//
//  Sets up start locations of cars
// -----------------------------------------------------------------------------

void CarGame::setupStart()
{
	// compute intersection of the path with the start line
	Tuple A = startLineA / kScale;
	Tuple B = startLineB / kScale;
	Tuple E, F;
	Tuple result(0,0);
	double s, t, divisor;
	list<Tuple>::const_iterator i, j;
	for (i = pathPolygon->begin(), (j = pathPolygon->end())--; i != pathPolygon->end(); j = i++) {
		E = *i;
		F = *j;
		divisor = A.x*(F.y-E.y)+B.x*(E.y-F.y)+(B.y-A.y)*F.x+(A.y-B.y)*E.x;
		s = -(B.x*(F.y-E.y)+E.x*(B.y-F.y)+(E.y-B.y)*F.x) / divisor;	// along path AB
		t = (A.x*(F.y-B.y)+B.x*(A.y-F.y)+(B.y-A.y)*F.x) / divisor;	// along path EF
		if (0 <= s && s < 1 && 0 <= t && t < 1) {
			result = s*A + (1-s)*B;
			break;
		}
	}

	// set start locations of all cars
	// we setup a two by two line behind the start line perpendicular to it
	Tuple vOffset = (A - B).Direction().perp();
	Tuple hOffset = vOffset.perp();
	double theta = atan2(-vOffset.y, -vOffset.x);
	Tuple placement;
	for (int k = 0; k < numPlayers; k++)
	{
		if (k % 2 == 0) {
			result += vOffset * players[k]->car.getWidth() / kScale;
			placement = result - hOffset * players[k]->car.getHeight() / kScale * 0.55;
		}
		else {
			placement = result + hOffset * players[k]->car.getHeight() / kScale * 0.55;
		}
		players[k]->car.setLocation(placement);
		players[k]->car.setOrientation(theta);
		players[k]->computePathLocation();
      players[k]->setNearestPathPos(computeNearestPathPosition(players[k]->car.getLocation_wc()));
	}

   /* This is a bt of a hack but it fixes the bug with the wheels being in the wrong spots
   at the start of the game. There is probably a better way to fix this bug but this should be fine for now. */
	list<Player*>::iterator playerI;
	for (playerI = playersInGame.begin(); playerI != playersInGame.end(); playerI++)
      (*playerI)->car.rk2_step(0.001);
}

// -----------------------------------------------------------------------------
//	CarGame::~CarGame
//
//  Destructor. Cleans up.
// -----------------------------------------------------------------------------

CarGame::~CarGame()
{
	int i;
#if HAVE_FMOD_LIB
	if (gPreferences->getSounds()) {
		FMOD_RESULT      result;
		/*
			Release sounds
		*/
		result = engineSound->release();
		ERRCHECK(result);
		result = crashSound->release();
		ERRCHECK(result);
		result = dustSlideSound->release();
		ERRCHECK(result);
		result = organC6Sound->release();
		ERRCHECK(result);
		result = organC7Sound->release();
		ERRCHECK(result);
	}
#endif

	// delete players
	for (i = 0; i < numPlayers; i++)
		delete players[i];
	delete [] players;

	// delete the views
	for (list<ViewFollow>::iterator i = views.begin(); i != views.end(); i++)
		delete i->view;

	// delete the minimap
	delete minimap;

	// delete the needle image
	delete needle;

	// delete the label images
	delete labelKPH;
	delete labelRPM;

	// detele the start lights
	for (i = 0; i < kNumStartLights; i++)
		delete lights[i];

	// delete the path polygon
	delete pathPolygon;

   // delete the sign intervals
   delete signIntervals;
}

// -----------------------------------------------------------------------------
//	CarGame::addView
//
//  Adds a view to the game with a given player to follow.
// -----------------------------------------------------------------------------

void CarGame::addView(ScPortRect& portRect, int playerFollow)
{
	ScRect viewRect = {0, 0, portRect.width, portRect.height};
	ScView* viewP = new ScView(portRect, viewRect, animation);
	views.push_back(ViewFollow(viewP, playerFollow));
}

// -----------------------------------------------------------------------------
//	CarGame::doEvent
//  Receive an event for a particular player.
// -----------------------------------------------------------------------------

void CarGame::doEvent(PlayerEvent* event, unsigned short playerNum)
{
    if (playerNum < numPlayers)
			players[playerNum]->doEvent(event);
}

// -----------------------------------------------------------------------------
//	CarGame::step
//
//  Calculate and draw a single frame of the game being played.
// -----------------------------------------------------------------------------

void CarGame::step(double dt)
{
	if (runningTime >= kNumStartLights-1)
		computePhysics(dt);
	animation.process(dt);

	for (list<Player*>::iterator i = playersInGame.begin(); i != playersInGame.end(); i++)
		(*i)->updateLaps(startLineA, startLineB, runningTime, clockwise);

	drawViews(dt);
   drawTime(runningTime);
	minimap->draw(150, 20, 1.0);

   runningTime += dt;
}

// -----------------------------------------------------------------------------
//	CarGame::isPlayerHuman
//
// Tells if the given player number is a human controlled player or not.
// -----------------------------------------------------------------------------

bool CarGame::isPlayerHuman(int i)
{
   if (i < numPlayers)
   {

      //RobotPlayer *rb = dynamic_cast<RobotPlayer*>(players[i]);
      //return rb == NULL;

      return players[i]->getPlayerType() == kPlayerType;
   }
   return false;
}

// -----------------------------------------------------------------------------
//	CarGame::renderEveryTexture
//
//  This should be called once before the beginning of the game. This function
//  renders all textures in the game once, which is necessary to load them into
//  VRAM. Without calling this, the game may run slowly at the beginning until
//  it has finally drawn every texture.
// -----------------------------------------------------------------------------

void CarGame::renderEveryTexture()
{
	int i;
	const ScRect& viewRect = views.front().view->getViewRect();
	WheelSprite* wheelSprite = players[0]->car.getLeftWheelSprite();
    ToyCar* carSprite;

    glLoadIdentity();
	glOrtho(0, viewRect.right - viewRect.left, 0, viewRect.top - viewRect.bottom, -1.0, 1.0);

	// render all the car sprite frames
    for (i = 0; i < numPlayers; i++)
    {
        carSprite = &players[i]->car;
        carSprite->moveTo(0,0);
        for (i = 0; i < carSprite->getNumFrames(); i++)
        {
            carSprite->setFrame(i);
            carSprite->doDraw();
        }
	}

	// render all the wheel sprite frames
	wheelSprite->moveTo(0,0);
	for (i = 0; i < wheelSprite->getNumFrames(); i++)
	{
		wheelSprite->setFrame(i);
		wheelSprite->doDraw();
	}

	// render the needle image
	needle->setDegrees(0);
	needle->draw();

   // render the label images
   labelKPH->draw();
   labelRPM->draw();

	// render the minimap image
	minimap->draw(0, 0, 1.0);
}

// -----------------------------------------------------------------------------
//	CarGame::computePhysics
//
//  Performs integration on forces for each car. Then checks for collisions
//  between cars and wall tiles. Then checks for collisions between all cars
//  in game. Finally calls resolveCollisions.
// -----------------------------------------------------------------------------

const double kStepFrequency = 500.0;	// number of integrations per second

void CarGame::computePhysics(double dt)
{
	list<Player*>::iterator playerI, playerJ;

	// perform numerical integration on vehicles
	// generate dust particles and integrate user inputs
	int j, steps = int(ceil(dt * kStepFrequency));
	double t, small_dt = dt / steps;
	for (playerI = playersInGame.begin(); playerI != playersInGame.end(); playerI++)
	{
		// integrate car dynamics and keyboard input and generate dust particles
		t = 0.0;
		for (j = 0; j < steps; j++)
		{
			(*playerI)->updatePathLocation();
         /*
			#if (MOUSE_CONTROL_PLAYER_1 || GAMEPAD_CONTROL_PLAYER_1)
			if ((*playerI)->getPlayerNumber() != 1)
			#endif
			*/
         // nb: if the player is an ai then it is controlled through the integrateKeys function so we should call it here
         if (gPreferences->getControllerType((*playerI)->getPlayerNumber()) == kKeyboardController || (*playerI)->isAI())
         {
				(*playerI)->integrateKeys(small_dt);
			}

			//#if GAMEPAD_CONTROL_PLAYER_1
			else
				(*playerI)->dampSteering(small_dt);
				//(*playerI)->integrateSteerKeys(small_dt);
			//#endif

			(*playerI)->car.computeWheelSurfaceFactors(&tilemap);
			(*playerI)->car.rk2_step(small_dt);

			t += small_dt;
			generateDustFromWheel((*playerI)->car.getWheel_FL(), small_dt, t);
			generateDustFromWheel((*playerI)->car.getWheel_FR(), small_dt, t);
			generateDustFromWheel((*playerI)->car.getWheel_BL(), small_dt, t);
			generateDustFromWheel((*playerI)->car.getWheel_BR(), small_dt, t);
		}

		// update geometry
		(*playerI)->car.compute_geom_world_coords();
	}

	// check for collisions
	list<Contact> contacts;
	for (playerI = playersInGame.begin(); playerI != playersInGame.end(); playerI++)
	{
		findTileContacts((*playerI)->car, contacts);
		for ((playerJ = playerI)++; playerJ != playersInGame.end(); playerJ++)
		{
			if (Geom::collide((*playerI)->car.getGeom_wc(), (*playerJ)->car.getGeom_wc(), contacts))
			{
                collisionAction(contacts, *playerI, *playerJ);
			}
		}
	}

	// ==========================================================================================
	// Play the collision sound if necessary
	// ==========================================================================================
#if HAVE_FMOD_LIB
	if (gPreferences->getSounds()) {
		double vel, minVel=0;   // note these will be negative values, so minimum is really maximum absolute value.
		Tuple collisionSoundLoc;
		for (list<Contact>::iterator i = contacts.begin(); i != contacts.end(); i++) {
			vel = i->compute_velocity();
			if (vel < minVel) {
				minVel = vel;
				collisionSoundLoc = i->getLoc();
			}
		}
		if (minVel < kCollisionThreshold) {
			FMOD_VECTOR pos = {  collisionSoundLoc.x,  collisionSoundLoc.y,  0.0f };
			FMOD_VECTOR vel = {  0.0f,  0.0f,  0.0f };
			FMOD_RESULT		result;
			FMOD::Channel	*channel3;

			result = FMOD_System->playSound(FMOD_CHANNEL_FREE, crashSound, false, &channel3);
			ERRCHECK(result);
			result = channel3->set3DAttributes(&pos, &vel);
			ERRCHECK(result);
			result = channel3->setVolume(0.1 + (-minVel) * 0.09);
			ERRCHECK(result);
		}
	}
#endif

	// ==========================================================================================
	// UPDATE THE LISTENER
	// n.b. We need to check that the player we are getting values from is still in the game.
	// Thus the use of the find function. The player may be out of the game for some reason.
	// ==========================================================================================
#if HAVE_FMOD_LIB
	if (gPreferences->getSounds()) {
		if (find(playersInGame.begin(), playersInGame.end(), players[0]) != playersInGame.end())
		{
			const FMOD_VECTOR up = { 0.0f, 0.0f, 1.0f };
			FMOD_VECTOR listenerpos;
			FMOD_VECTOR forward;
			FMOD_VECTOR vel;
			FMOD_RESULT result;

			listenerpos.x = players[0]->car.getLocation_wc().x;
			listenerpos.y = players[0]->car.getLocation_wc().y;
			listenerpos.z = 0;

			vel.x = players[0]->car.getVelocity_wc().x;
			vel.y = players[0]->car.getVelocity_wc().y;
			vel.z = 0;

			forward.x = -players[0]->car.getNorm().y;
			forward.y = players[0]->car.getNorm().x;
			forward.z = 0;

			result = FMOD_System->set3DListenerAttributes(0, &listenerpos, &vel, &forward, &up);
			ERRCHECK(result);
		}

		// ==========================================================================================
		// UPDATE THE SOURCES (Engine sounds and dust sounds)
		// ==========================================================================================
		for (list<Player*>::iterator i = playersInGame.begin(); i != playersInGame.end(); i++)
		{
			(*i)->updateSounds();
		}

		//if (fabs(players[0]->car.getVelocity_wc().x*players[0]->car.getVelocity_wc().x + players[0]->car.getVelocity_wc().y*players[0]->car.getVelocity_wc().y) > 100*100)
		//	printf("Yikes\n");

		// Tell FMOD to update internals
		FMOD_System->update();
	}
#endif

	resolveCollisions(contacts);
}

double CarGame::computeCameraRotation(const ScView *view, const Player *player, double dt)
{
   double rot = view->getRotation();
   double dr = (cameraMode == kRotoZoomingCamera ? -(player->car.getOrientation_wc() * 180 / kPi - 90) : 0) - rot;
   while (dr > 180)
      dr -= 360;
   while (dr < -180)
      dr += 360;
   if (fabs(dr) > 1e4*dt)
      dr = (dr > 0 ? 1 : -1)*1e4*dt;
   rot += dt*dr*4;
   return rot;
}

double CarGame::computeCameraZoom(const ScView *view, const Player *player, double dt)
{
   double zoom = view->getZoom();
   double dz = (cameraMode != kFixedCamera ? 1 / (0.001*sqr(player->car.getVelocity().x) + 1) : 1) - zoom;
   zoom += dt*dz*4;
   return zoom;
}

// -----------------------------------------------------------------------------
//	CarGame::drawViews
//
//  Scrolls views. Bounds the scrolling to the game rect. Invokes the draw
//  function for each view. Draws additional things for each view such as
//  speedometre and engine rpm of the corresponding player.
// -----------------------------------------------------------------------------

void CarGame::drawViews(double dt)
{
   glClear(GL_COLOR_BUFFER_BIT);
	for (list<ViewFollow>::iterator i = views.begin(); i != views.end(); i++)
	{
		// scroll the view to the car location

		i->view->scrollTo(	floor(players[i->follow]->car.getLocation_wc().x * kScale),
							floor(players[i->follow]->car.getLocation_wc().y * kScale));

		// bound the view to the animation bounds

		if (i->view->getViewRect().left < gameRect.left)
			i->view->scrollBy(gameRect.left - i->view->getViewRect().left, 0);

		if (i->view->getViewRect().bottom < gameRect.bottom)
			i->view->scrollBy(0, gameRect.bottom - i->view->getViewRect().bottom);

		if (i->view->getViewRect().right > gameRect.right)
			i->view->scrollBy(gameRect.right - i->view->getViewRect().right, 0);

		if (i->view->getViewRect().top > gameRect.top)
			i->view->scrollBy(0, gameRect.top - i->view->getViewRect().top);

		// compute rotation and zoom of camera

      i->view->setRotation(computeCameraRotation(i->view, players[i->follow], dt));
      i->view->setZoom(computeCameraZoom(i->view, players[i->follow], dt));

      // draw scene

      i->view->draw();

		//
		// draw display
		//
		glLoadIdentity();
		glOrtho(0, i->view->getViewRect().right - i->view->getViewRect().left, 0, i->view->getViewRect().top - i->view->getViewRect().bottom, -1, 1);
		drawDisplay(players[i->follow], i->view->getViewRect(), dt);
	}
}

void CarGame::drawDisplay(Player *player, const ScRect& viewRect, double dt)
{
	drawSpeedometer(player);
	drawRPMMeter(player);
	drawLapCount(player);
	if (player->getLaps() >= kNumLaps)
		drawFinishTime(player);
	drawLights();
   drawSign(player, viewRect, dt);
}

double CarGame::computeNearestPathPosition(Tuple pos) {
   double bestPathDist = 0;
   double curPathDist = 0;
   double bestNormDist = INFINITY;
   Tuple p, norm;
   double len, x, dist;
   for (list<Tuple>::const_iterator it = pathPolygon->begin(); it != pathPolygon->end(); it++) {
      list<Tuple>::const_iterator next = it;
      next++;
      if (next == pathPolygon->end())
         next = pathPolygon->begin();
      // project pos onto the line it..next
      p = *next - *it;
      len = p.Normalise();
      x = p * (pos - *it);
      // check if this edge is the closest to pos so far
      if (0 <= x && x <= len) {
         norm = (x * p) + *it;
         dist = (norm - pos).Norm();
         if (dist < bestNormDist) {
            bestNormDist = dist;
            bestPathDist = curPathDist + x;
         }
      }
      // check if this vertrex is the closest to pos so far
      dist = (*it - pos).Norm();
      if (dist < bestNormDist) {
         bestNormDist = dist;
         bestPathDist = curPathDist;
      }
      curPathDist += len;
   }
   return bestPathDist;
}

double CarGame::computeTotalPathLength() {
   double dist = 0;
   list<Tuple>::const_iterator tmp;
   for (list<Tuple>::const_iterator it = pathPolygon->begin(); it != pathPolygon->end(); it++) {
      tmp = it;
      tmp++;
      if (tmp == pathPolygon->end())
         tmp = pathPolygon->begin();
      dist += (*tmp - *it).Length();
   }
   return dist;
}

const RoadSignInterval *CarGame::findRoadSignInterval(Player *player) {
   double pos = computeNearestPathPosition(player->car.getLocation_wc());
   double bigpos = pos + totalPathLength;
   for (list<RoadSignInterval>::const_iterator it = signIntervals->begin(); it != signIntervals->end(); it++) {
      if (it->start <= pos && pos <= it->end) {
         return &(*it);
      }
      if (it->start <= bigpos && bigpos <= it->end) {
         return &(*it);
      }
   }
   return NULL;
}

void CarGame::drawSign(Player *player, const ScRect& viewRect, double dt)
{
   double modTime;
   modTime = fmod(runningTime, kWrongWayCheckInterval);
   if (modTime < 1 && modTime+dt > 1) {
      double pos = computeNearestPathPosition(player->car.getLocation_wc());
      player->setRightWay((pos+kWrongWayPosOffset > player->getNearestPathPos() || player->getNearestPathPos() - pos > totalPathLength*0.5) &&
         pos - player->getNearestPathPos() < totalPathLength*0.5);
      player->setNearestPathPos(pos);
   }

   const RoadSignInterval *s = findRoadSignInterval(player);
   if (s && player->getRightWay()) {
      if (player->getSignFade() < 1) {
         player->setSignFade(player->getSignFade() + dt * kSignFadeSpeed);
      }
      player->setLastRoadSignInterval(s);
      signsSprite->setFrame(s->type);
      signsSprite->moveTo((viewRect.right - viewRect.left)*0.5, (viewRect.top - viewRect.bottom)*kSignScreenPosition);
      signsSprite->setTransparency(player->getSignFade());
      signsSprite->doDraw();
   }
   else if (player->getSignFade() > 0) {
      player->setSignFade(player->getSignFade() - dt * kSignFadeSpeed);
      if (player->getLastRoadSignInterval() != NULL) {
         signsSprite->setFrame(player->getLastRoadSignInterval()->type);
         signsSprite->moveTo((viewRect.right - viewRect.left)*0.5, (viewRect.top - viewRect.bottom)*kSignScreenPosition);
         signsSprite->setTransparency(player->getSignFade());
         signsSprite->doDraw();
      }
   }

   if (!player->getRightWay()) {
      glDisable(GL_TEXTURE_2D);
      glEnable(GL_BLEND);
      glColor4f(1,0,0,1);
      glTranslatef((viewRect.right - viewRect.left)*0.5, (viewRect.top - viewRect.bottom)*kWrongWayScreenPosition, 0);
      glScalef(12, 12, 1);
      glfDrawSolidString("Wrong way");
   }
}

void CarGame::drawLights()
{
	if (runningTime < kNumStartLights+1) {
		glPushMatrix();
		glTranslatef(100, 300, 0);
		int k = int(runningTime);
#if HAVE_FMOD_LIB
		if (gPreferences->getSounds()) {
			if (k != lastLight) {
				// play sound
				FMOD::Channel	*channel;
				FMOD_RESULT		result;
				if (k <= kNumStartLights-2) {
					result = FMOD_System->playSound(FMOD_CHANNEL_FREE, organC6Sound, false, &channel);
					ERRCHECK(result);
				}
				else if (k == kNumStartLights-1) {
					result = FMOD_System->playSound(FMOD_CHANNEL_FREE, organC7Sound, false, &channel);
					ERRCHECK(result);
				}
			}
		}
#endif
		if (k == kNumStartLights)
			lights[k-1]->draw((unsigned char)(255*(4 - runningTime)));
		else
			lights[k]->draw();
		glPopMatrix();
		lastLight = k;
	}
}

void CarGame::drawSpeedometer(Player *player)
{
	glPushMatrix();
	needle->setDegrees(player->car.getVelocity().x*5 - 90.0);
	glTranslatef(100, 64, 0);
	glPushMatrix();
	glTranslatef(0, -16, 0);
	glScalef(0.5, 0.5, 1);
   labelKPH->draw();
	glPopMatrix();
	needle->draw();
	glPopMatrix();
}

void CarGame::drawRPMMeter(Player *player)
{
	glPushMatrix();
	needle->setDegrees(player->car.getRPM()*0.1 - 90.0);
	glTranslatef(200, 64, 0);
	glPushMatrix();
	glTranslatef(0, -16, 0);
	glScalef(0.5, 0.5, 1);
   labelRPM->draw();
	glPopMatrix();
	needle->draw();
	glPopMatrix();
}

void CarGame::drawLapCount(Player *player)
{
	static char str15[16];
	glDisable(GL_TEXTURE_2D);
	glEnable(GL_BLEND);
	glColor4f(1.0f,1.0f,1.0f,0.5f);
	glPushMatrix();
	glTranslatef(24, gPreferences->getScreenHeight()-48, 0);
	glScalef(10, 10, 1);
	//sprintf(str15, "Laps: %d\nDist: %lf\npathIndex: %d", player->getLaps(), player->getActualPathDistance(), player->getPathIndex());
	sprintf(str15, "Laps: %d/%d", player->getLaps(), kNumLaps);
	glfDrawSolidString(str15);
	glPopMatrix();
}

void CarGame::drawFinishTime(Player *player)
{
	static char str15[16];
	glPushMatrix();
	glScalef(12, 12, 1);
	glTranslatef(2, gPreferences->getScreenHeight()/24.0 + 1, 0);
	sprintf(str15, "Finish time: %.2lf s", player->getCourseTime());
	glfDrawSolidString(str15);
	glTranslatef(0, -2, 0);
	sprintf(str15, "Best lap time: %.2lf s", player->getBestLapTime());
	glfDrawSolidString(str15);
	glPopMatrix();
}

// -----------------------------------------------------------------------------
//	CarGame::drawTime
//
//  Takes time in seconds and renders clock digits
// -----------------------------------------------------------------------------

void CarGame::drawTime(double theTime)
{
	static char str31[32];

	glDisable(GL_TEXTURE_2D);
	glEnable(GL_BLEND);
	glColor4f(1.0f,1.0f,1.0f,0.5f);

	glLoadIdentity();
	glOrtho(0, gPreferences->getScreenWidth(), 0, gPreferences->getScreenHeight(), -1, 1);
	glViewport(0, 0, gPreferences->getScreenWidth(), gPreferences->getScreenHeight());
	glTranslatef(24, gPreferences->getScreenHeight()-24, 0);

	int minutes = int(theTime) / 60;
	sprintf(str31, "%d:%.2lf", minutes, theTime - 60*minutes);
	glScalef(12, 12, 1);
	glfDrawSolidString(str31);
}

// -----------------------------------------------------------------------------
//	CarGame::findTileContacts
//
//  Compute contacts for any collisions between car and tiles.
// -----------------------------------------------------------------------------

void CarGame::findTileContacts(ToyCar& car, list<Contact>& contacts)
{
/*
	const double radius = car.getGeomRadius();
	const Tuple pos = car.getLocation_wc();
    int firstrow = int((pos.y - radius) * kScale) / tilemap.getTileHeight();
    int lastrow = int((pos.y + radius) * kScale) / tilemap.getTileHeight();
    int firstcol = int((pos.x - radius) * kScale) / tilemap.getTileWidth();
    int lastcol = int((pos.x + radius) * kScale) / tilemap.getTileWidth();
*/
    int firstrow = int(car.getBounds().bottom) / tilemap.getTileHeight();
    int lastrow = int(car.getBounds().top) / tilemap.getTileHeight();
    int firstcol = int(car.getBounds().left) / tilemap.getTileWidth();
    int lastcol = int(car.getBounds().right) / tilemap.getTileWidth();
    int row, col;

	firstrow = std::max(firstrow, 0);
	lastrow = std::min(lastrow, (tilemap.getMapHeight() - 1));
	firstcol = std::max(firstcol, 0);
	lastcol = std::min(lastcol, (tilemap.getMapWidth() - 1));

    list<block> blocks;

    for (row = firstrow; row <= lastrow; row++)
    {
        for (col = firstcol; col <= lastcol; col++)
        {
            if (tilemap(col,row) == kWallTile)
            {
                blocks.push_back(block(col+1,col,row+1,row));
            }
        }
    }

    sewSeams(blocks);

    for (list<block>::const_iterator i = blocks.begin(); i != blocks.end(); i++)
    {
        ToyCars::Rectangle block(	i->right * tilemap.getTileWidth() / kScale,
							i->left * tilemap.getTileWidth() / kScale,
							i->top * tilemap.getTileHeight() / kScale,
							i->bottom * tilemap.getTileHeight() / kScale);

        Geom::collide(car.getGeom_wc(), block, contacts);
	}
}

// -----------------------------------------------------------------------------
//	CarGame::sewSeams
//
//  This algorithm reduces a list of blocks to one where there are no 'seams'.
//  A seam is two blocks sharing a common edge. Applying this to the list
//  significantly improves collision detection with the blocks.
//
//  If we do not apply this algorithm to the list of blocks, then crashing
//  into a straight wall sometimes behaves as if the car is crashing into the
//  corner of one of the tiles in the wall, producing a very undesirable effect.
// -----------------------------------------------------------------------------

void CarGame::sewSeams(list<block>& blocks)
{
    bool seam_found;
    list<block>::iterator tileA, tileB;

    do
    {
        seam_found = false;

        for (tileA = blocks.begin(); tileA != blocks.end() && !seam_found; tileA++)
        {
            for ((tileB = tileA)++; tileB != blocks.end() && !seam_found; tileB++)
            {
                // check for seams between tileA and tileB

                if (tileA->top == tileB->top && tileA->bottom == tileB->bottom)
                {
                    if (tileA->right == tileB->left)
                    {
                        tileB->left = tileA->left;
                        blocks.erase(tileA);
                        seam_found = true;
                    }
                    else if (tileB->right == tileA->left)
                    {
                        tileB->right = tileA->right;
                        blocks.erase(tileA);
                        seam_found = true;
                    }
                }
                else if (tileA->left == tileB->left && tileA->right == tileB->right)
                {
                    if (tileA->top == tileB->bottom)
                    {
                        tileB->bottom = tileA->bottom;
                        blocks.erase(tileA);
                        seam_found = true;
                    }
                    else if (tileB->top == tileA->bottom)
                    {
                        tileB->top = tileA->top;
                        blocks.erase(tileA);
                        seam_found = true;
                    }
                }
            }
			if (seam_found)
				break;
        }
    }
    while (seam_found);
}

// -----------------------------------------------------------------------------
//	CarGame::resolveCollisions
//
//  Attempts to resolve all the collisions in the given contact list.
//  An iterative method is used. Overlap error is compensated for by
//  translating bodies away from each other in resolve_overlap().
// -----------------------------------------------------------------------------

void CarGame::resolveCollisions(list<Contact>& contacts)
{
    list<Contact>::iterator c;
	bool collisions;
	unsigned char maxIterations = 20;

	// resolve collisions

    do
    {
		collisions = false;
        for (c = contacts.begin(); c != contacts.end(); c++)
        {
            if (c->resolve_collision()) {
				collisions = true;
			}/*
			if (c->compute_velocity() > 4.0) {
				printf("bang\n");
			}*/
        }
    }
	while (collisions && --maxIterations);

	// seperate overlaps

    for (c = contacts.begin(); c != contacts.end(); c++)
    {
        c->resolve_overlap();
    }
}

// -----------------------------------------------------------------------------
//	CarGame::generateDustFromWheel
//
//  Computes the dust particles sprayed out by the given wheel over a given
//  time period dt (usually very short).
//
//  Time of creation of the particles can be moved backwards by specifying a
//  positive value for rewind. The reason for this is because this function may
//  be called at many sub-frame times for each frame (ie during integration of
//  forces and velocities). One wants to synchronise the particles however, as
//  if they were created on the actual start of the frame. Otherwise, they will
//  look not right.
// -----------------------------------------------------------------------------

const double kDustProliferation = 25.0;
const double kDustLife = 1.2;

void CarGame::generateDustFromWheel(const Wheel& wheel, double dt, double rewind)
{
	int numParticles, i;
	Tuple lat, longt, loc;
	const Vehicle& vehicle = wheel.getVehicle();
	double dustVel;
   const TileGroup *group;

	// local class rround
	// rounds off x based on probability from fractional part
	class _rround
	{
	public:
		int operator() (double x)
		{
			if (x - floor(x) > drand48())
				return (int)(x) + 1;
			else
				return (int)(x);
		}
	}rround;

	// tyre location in world coords
	loc = (vehicle.getLocation_wc() + vehicle.getNorm().fromLocal(wheel.getLocation_vc())) * kScale;

   // get tile group
   group = tilemap.tileGroup(tilemap.getTileAtPoint(loc.x, loc.y));

	// dust direction in world coords
	lat = vehicle.getNorm().fromLocal(wheel.getNorm());
	longt = -lat.perp();

	// dust from longtitudinal slip
	dustVel = wheel.getLongtitudinalSlipVelocity();
	if (fabs(dustVel) > 5.0)
	{
		numParticles = rround(dt * kLongtitudinalDustFactor*kDustProliferation * fabs(dustVel));
		//if (numParticles) particles->newParticle(Particle(loc.x, loc.y, 10.0, 0, 0, 0));
		for (i = 0; i < numParticles; i++)
			particles->newParticle(Particle(loc.x, loc.y, kDustLife, longt.x + (drand48()-0.5)/dustVel*4.0, longt.y + (drand48()-0.5)/dustVel*4.0, dustVel * kScale, group->r, group->g, group->b).step(-rewind));
	}

	// dust from lateral slip
	dustVel = wheel.getVelocity().y;
	if (fabs(dustVel) > 5.0)
	{
		numParticles = rround(dt * kLateralDustFactor*kDustProliferation * fabs(dustVel));
		//if (numParticles) particles->newParticle(Particle(loc.x, loc.y, 10.0, 0, 0, 0));
		for (i = 0; i < numParticles; i++)
			particles->newParticle(Particle(loc.x, loc.y, kDustLife, lat.x + (drand48()-0.5)/dustVel*4.0, lat.y + (drand48()-0.5)/dustVel*4.0, dustVel * kScale, group->r, group->g, group->b).step(-rewind));
	}
}