src/main.cpp

Go to the documentation of this file.

 // vim: set noet sw=8 cino=:
#define GL_GLEXT_PROTOTYPES

#include <fenv.h>

#include <stdio.h>
#include <stdlib.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glext.h>
#include <SDL/SDL.h>
#include <math.h>
#include <string>
#include <vector>

using namespace std;

#include "font.h"
#include "utility.h"
#include "textures.h"
#include "backdrop.h"
#include "camera.h"
#include "weather.h"
#include "keyman.h"
#include "mouse.h"
#include "messageq.h"
#include "particles.h"
/*#include "mesh.h"                     // Header File For The MESH Class
#include "entity.h"                     // ...etc
#include "meshlist.h"
#include "entitylist.h"
#include "water.h"
#include "model.h"
#include "gamedb.h"
#include "ships.h"*/
#include "settings.h"
#include "sound.h"
/* #include "menu.h" */
#include "timer.h"
#include "controls.h"
#include "vamosworld.h"
#include "replay.h"
//#include "trees.h"
#include "logo.h"
#include "gamestate.h"
#include "objects.h"
#include "multiplay.h"
#include "net.h"
#include "configfile.h"
#include "bezier.h"
#include "track.h"
#include "textures.h"
#include "exception.h"
#include "cardinfo.h"

using namespace VDrift;

#include <vamos/body/Gl_Car.h>
#include <vamos/geometry/Texture_Image.h>
#include <vamos/geometry/Three_Vector.h>
//#include <vamos/track/Strip_Track.h>
#include <vamos/body/Car.h>
#include <vamos/body/Fuel_Tank.h>
#include <vamos/body/Wheel.h>
#include <vamos/geometry/Conversions.h>
//#include <vamos/track/Track.h>
#include <vamos/world/World.h>

#include "gui/gui.h"

#ifdef _WIN32
//#define GL_GLEXT_PROTOTYPES
#include <GL/glext.h>
//#include <GL/wglext.h>
//#include <GL/glprocs.h>
#endif

//#define PERFORMANCE_PROFILE

//fps less than below will not tick the simulation
//#define MIN_FPS 5.0

#ifdef PERFORMANCE_PROFILE
#include <sys/time.h>
suseconds_t GetMicroSeconds()
{
        struct timeval tv;
        struct timezone tz;
                
        tz.tz_minuteswest = 0;
        tz.tz_dsttime = 0;
        
        gettimeofday(&tv, &tz);
        
        return tv.tv_usec;
}
#endif


// Set up some booleans
#define TRUE  1
#define FALSE 0

// screen width, height, and bit depth
//const int SCREEN_WIDTH = 1024;
//const int SCREEN_HEIGHT = 768;
//const int SCREEN_BPP = 32;

int SCREEN_WIDTH = 1024;
int SCREEN_HEIGHT = 768;
int SCREEN_BPP = 32;

//#define PATCH_DEBUG

bool verbose_output = false;

//bool in_menu = false;
//bool menu_display = false;

/*const int SCREEN_WIDTH = 1280;
const int SCREEN_HEIGHT = 1024;
const int SCREEN_BPP = 32;*/

// This is our SDL surface
SDL_Surface *surface;

// Ambient Light Values ( NEW )
//GLfloat LightAmbient[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat LightAmbient[]  = { 0.15f, 0.15f, 0.15f, 1.0f };
// Diffuse Light Values ( NEW )
//GLfloat LightDiffuse[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat LightDiffuse[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat LightSpecular[]  = { 0.0f, 0.0f, 0.0f, 0.0f };
// Light Position ( NEW )
GLfloat LightPosition[4];

/*
ENTITYLIST entities;
MESHLIST meshes;
TERRAIN terrain;
TREES foliage;
WATER water;
GAMEDB gamedb;
SHIPS ships;*/
KEYMAN keyman;
GAMECONTROLS gamecontrols;
SETTINGS settings;
TEXTURES textures;
CAMERA cam;
FONT font;
UTILITY utility;
BACKDROP backdrop;
WEATHER weathersystem;
MOUSE mouse;
MESSAGEQ mq1;
//TERRAIN terrain;
PARTICLE particle;
SOUNDMANAGER sound;
/* MENU menu; */
TIMER timer;
REPLAY replay;
//TREES trees;
LOGO logo;
GAMESTATE state;
OBJECTS objects;
NET net;
MULTIPLAY multiplay;
VGUI::Gui gui;
TRACK track;
CARDINFO gfxcard;

VAMOSWORLD world;
//Vamos_Track::Strip_Track *road;

ofstream error_log;

#define CAR_Y_OFFSET 1.0

double day_time;
double abs_time;

//for game timing and FPS stuff
static GLint T0;
static GLint Frames;
static GLfloat fps;

bool showfps;

static int frameno;

float timefactor = 1.0f;

//#define AVERAGEFRAMES 30
#define AVERAGEFRAMES 5

float pfps;
float lfps[AVERAGEFRAMES];
int lfpspos = 0;
bool lfpsfull = false;

//#define FRAME_TIME 0.002
#define FRAME_TIME 0.004
double execution_time = 0.0;

bool pauserequest = false;
bool unpauserequest = false;
bool esc_pressed = false;

float view_dist = 10000.0;

//int screenshots = 0;
string cur_tex_size = "";
int cur_screen_w = 0;
int cur_screen_h = 0;
int cur_screen_bpp = 0;
bool cur_fullscreen = false;
string tree_detail = "";

float FrameTime()
{
        return FRAME_TIME;
}

int Screenshot(char *filename)
{
        SDL_Surface *screen;
        SDL_Surface *temp = NULL;
        unsigned char *pixels;
        int i;
        
        screen = surface;
        
        if (!(screen->flags & SDL_OPENGL))
        {
                SDL_SaveBMP(temp, filename);
                return 0;
        }
        
        temp = SDL_CreateRGBSurface(SDL_SWSURFACE, screen->w, screen->h, 16,
        #if SDL_BYTEORDER == SDL_LIL_ENDIAN
        0x000000FF, 0x0000FF00, 0x00FF0000, 0
        #else
        0x00FF0000, 0x0000FF00, 0x000000FF, 0
        #endif
        );
        if (temp == NULL)
                return -1;
        
        pixels = (unsigned char *) malloc(3 * screen->w * screen->h);
        if (pixels == NULL)
        {
                SDL_FreeSurface(temp);
                return -1;
        }
        
        glReadPixels(0, 0, screen->w, screen->h, GL_RGB, GL_UNSIGNED_BYTE, pixels);
        
        for (i=0; i<screen->h; i++)
                memcpy(((char *) temp->pixels) + temp->pitch * i, pixels + 3*screen->w * (screen->h-i-1), screen->w*3);
        free(pixels);
        
        SDL_SaveBMP(temp, filename);
        SDL_FreeSurface(temp);
        return 0;
}

void ResetWorld(bool fullreset);

void Quit(int returnCode)
{
        state.SetGameState(STATE_EXIT);

        if (replay.Recording() != -1)
                replay.Stop();

        gamecontrols.WriteControlFile();

        if (verbose_output)
                cout << "Quit called" << endl;

        error_log.close();

        /* clean up the window */
        SDL_Quit( );

        if (verbose_output)
                cout << "SDL_Quit finished" << endl;

        exit(returnCode);
}

// function to reset our viewport after a window resize
int resizeWindow( int width, int height )
{
        // Height / width ration
        GLfloat ratio;
 
        // Protect against a divide by zero
        if ( height == 0 )
                height = 1;

        ratio = ( GLfloat )width / ( GLfloat )height;

        // Setup our viewport.
        glViewport( 0, 0, ( GLint )width, ( GLint )height );

        // change to the projection matrix and set our viewing volume.
        glMatrixMode( GL_PROJECTION );
        glLoadIdentity( );

        // Set our perspective
        gluPerspective( 45.0f, ratio, 0.1f, 10000.0f );

        // Make sure we're chaning the model view and not the projection
        glMatrixMode( GL_MODELVIEW );

        // Reset The View
        glLoadIdentity( );

        return( TRUE );
}

void LoadingScreen(string loadtext);

void ChangeDisplay(int w, int h, int bpp, bool fullscreen, bool reloadtextures)
{
        SCREEN_WIDTH = w;
        SCREEN_HEIGHT = h;
        SCREEN_BPP = bpp;
        
        // the flags to pass to SDL_SetVideoMode
        int videoFlags = SDL_OPENGL;       // Enable OpenGL in SDL
        videoFlags |= SDL_GL_DOUBLEBUFFER; // Enable double buffering
        videoFlags |= SDL_HWPALETTE;       // Store the palette in hardware
        videoFlags |= SDL_RESIZABLE;       // Enable window resizing

        // This checks to see if surfaces can be stored in memory
        /*if ( videoInfo->hw_available )
                videoFlags |= SDL_HWSURFACE;
        else
                videoFlags |= SDL_SWSURFACE;

        if ( videoInfo->blit_hw )
                videoFlags |= SDL_HWACCEL;*/

        if (fullscreen)
        {
                videoFlags |= SDL_HWSURFACE|SDL_ANYFORMAT|SDL_FULLSCREEN;  
        }       
        else
        {
                videoFlags |= SDL_SWSURFACE|SDL_ANYFORMAT;
        }

        // get a SDL surface
        if (surface != NULL)
        {
                SDL_FreeSurface(surface);
                surface = NULL;
        }
        surface = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, videoFlags );

        resizeWindow( SCREEN_WIDTH, SCREEN_HEIGHT );

        if (reloadtextures)
        {
                if( gui.GetEnabled() ) gui.SetEnabled( false );
                LoadingScreen("Loading...\nReloading textures");
                //textures.DeleteAll();
                textures.ReloadAll();
                LoadingScreen("Loading...\nFont");
                font.Load();
                LoadingScreen("Loading...\nBackdrop");
                backdrop.Init();
                //menu.Load();
                LoadingScreen("Loading...\nGame Controls");
                gamecontrols.LoadControls();
                LoadingScreen("Loading...\nParticles");
                particle.Load();
                LoadingScreen("Loading...\nTimer");
                timer.Load();
                LoadingScreen("Loading...\nHUD");
                world.UnloadHUD();
                world.LoadHUD();
                LoadingScreen("Loading...\nUser interface");
                //gui.DeInit();
                gui.ReInit();
                //menu.MainMenu();
                //gui.ChangePage( "Main" );
                //gui.SetEnabled( true );
        }

        gui.UpdateScreenSize();
}

void ReloadDisplay()
{
        string tex_size;
        int w, h, bpp;
        bool fullscreen, show_fps, reload_tex;

        settings.Get( "display.width", w );
        settings.Get( "display.height", h );
        settings.Get( "display.depth", bpp );
        settings.Get( "display.fullscreen", fullscreen );
        settings.Get( "display.show_fps", show_fps );
        settings.Get( "display.texture_size", tex_size );
        settings.Get( "display.view_distance", view_dist );
        settings.Get( "display.tree_detail", tree_detail );

        reload_tex = ( tex_size == cur_tex_size ) &&
                     ( w == cur_screen_w ) &&
                     ( h == cur_screen_h ) &&
                     ( fullscreen == cur_fullscreen ) &&
                     ( bpp == cur_screen_bpp ) ? false : true;
        reload_tex = true;

        showfps = show_fps;
        world.UpdateSettings();
        objects.UpdateSettings();
        //trees.UpdateSettings();
        //terrain.UpdateSettings();
        ChangeDisplay( w, h, bpp, fullscreen, reload_tex );
        cur_tex_size = tex_size;
        cur_screen_w = w;
        cur_screen_h = h;
        cur_screen_bpp = bpp;
        cur_fullscreen = fullscreen;
}

void Update()
{
        //cam.position.DebugPrint();

        if (MP_DBGDEEP)
                cout << "main update start" << endl;

        bool mainloop = false;

        //if unpaused and getting a reasonable framerate
        //if (fps > MIN_FPS && timefactor != 0.0f)
        if (fps > 0.0f && timefactor != 0.0f && state.GetGameState() != STATE_INITIALMENU)
        {
                /*VERTEX campos = cam.position;
                campos.Scale(-1.0);
                cout << campos.x << "," << campos.z << ": " << track.Elevation(campos) << endl;*/
                
                
                execution_time += timefactor / fps;
                int num_updates = (int) (execution_time / FRAME_TIME);
                double this_frame = (double) num_updates * FRAME_TIME;

                mouse.Update(cam, SCREEN_WIDTH, SCREEN_HEIGHT, timefactor, fps);
                weathersystem.Update(abs_time);

                while (execution_time > FRAME_TIME)
                {
                        #ifdef PERFORMANCE_PROFILE
                        suseconds_t t1, t2;
                        t1 = GetMicroSeconds();
                        t1 = GetMicroSeconds();
                        #endif

                        //multiplay.Update(FRAME_TIME);
                        
                        //weather tick

                        #ifdef PERFORMANCE_PROFILE
                        t2 = GetMicroSeconds();
                        cout << "multiplay.Update() ticks: " << t2-t1 << endl;
                        t1 = GetMicroSeconds();
                        #endif

                        //timer tick
                        //timer.TickTimer(timefactor,fps);
                        timer.TickTimer(1.0, 1.0/FRAME_TIME);

                        cam.Update();

                        //handle input
                        //keyman.DoHeldKeys(timefactor, fps, cam);
                        keyman.DoHeldKeys(1.0, 1.0/FRAME_TIME, cam);

                        #ifdef PERFORMANCE_PROFILE
                        t1 = GetMicroSeconds();
                        t1 = GetMicroSeconds();
                        #endif

                        //world.Update(timefactor, fps, js);
                        world.Update(1.0, 1.0/FRAME_TIME, gamecontrols.Get_js());

                        #ifdef PERFORMANCE_PROFILE
                        t2 = GetMicroSeconds();
                        cout << "world update ticks: " << t2-t1 << endl;
                        t1 = GetMicroSeconds();
                        #endif

                        keyman.DoOneTimeKeys(cam);

                        //particle.Update(timefactor, fps);
                        //particle.Update(1.0, 1.0/FRAME_TIME);

                        cam.ExtractFrustum();

                        LightPosition[0] = cos(backdrop.sunpos_lat);
                        LightPosition[1] = sin(backdrop.sunpos_lat);
                        if (LightPosition[1] < 0)
                                LightPosition[1] *= 10.0f; //to simulate sun disappearing behind horizon
                        LightPosition[2] = 0.0f;//tan(backdrop.sunpos_lng);

                        float dusktime = 0.5;
                        float dawntime = 0.0;
                        float transtime = 0.05;

                        float diffuse = 1.0f;
                        if (day_time >= dusktime || day_time <= dawntime)
                        {
                                diffuse = 0.0;
                        }

                        if (day_time > dawntime && day_time < transtime)
                        {
                                diffuse = day_time / (transtime);
                        }

                        if (day_time > dusktime - transtime && day_time < dusktime)
                        {
                                diffuse = (day_time - dusktime - transtime) / transtime;
                        }

                        diffuse = diffuse*0.9+0.1;

                        VERTEX ld;
                        ld.Set(LightDiffuse[0], LightDiffuse[1], LightDiffuse[2]);
                        ld.Scale(diffuse);
                        glLightfv( GL_LIGHT1, GL_DIFFUSE, ld.v3() );

                        //float timepassed = (timefactor/fps)/86400.0;
                        float timepassed = (FRAME_TIME)/86400.0;
                        /*if (keyman.keys[keyman.GetKey("AccelTimeVFast")])
                                timefactor = 10000.0;
                        else if (keyman.keys[keyman.GetKey("AccelTimeFast")])
                                timefactor = 1000.0;
                        else
                                timefactor = 1.0;*/
                        //float timepassed = (timefactor/fps)/60.0;
                        //float timepassed = (timefactor/fps)/10.0;
                        abs_time += timepassed;
                        day_time += timepassed;
                        if (day_time > 1.0f)
                                day_time -= 1.0f;

                        #ifdef PERFORMANCE_PROFILE
                        t2 = GetMicroSeconds();
                        cout << "Time increment ticks: " << t2-t1 << endl;
                        t1 = GetMicroSeconds();
                        #endif

                        multiplay.Send(FRAME_TIME);

                        mainloop = true;

                        //terrain.Update(cam, timefactor, fps, day_time);
                        //terrain.Update(cam, 1.0, 1.0/FRAME_TIME, day_time);

                        execution_time -= FRAME_TIME;
                        num_updates++;

                        //replay.IncrementFrame();
                }
                particle.Update(1.0, 1.0/this_frame);
//              terrain.Update(cam, 1.0, 1.0/this_frame, day_time);
        }
        else
        {
                //print "paused"
                if (state.GetGameState() != STATE_INITIALMENU)
                        world.Update(timefactor, fps, gamecontrols.Get_js());
        }

        if (pauserequest)
        {
                if (timefactor != 0.0f)
                        timefactor = 0.0f;
                pauserequest = false;
        }
        if (unpauserequest)
        {
                if (timefactor == 0.0f)
                        timefactor = 1.0f;
                unpauserequest = false;
        }

        sound.Update();
        /*if (!mainloop)
                multiplay.Update(0);*/ //don't need this anymore because we're stopping things from being paused in multiplayer mode

        if (MP_DBGDEEP)
                cout << "main update done" << endl;
}

void snap_screenshot()
{
        char scrname[64];
        int num_shots;
        settings.Get( "game.num_shots", num_shots );
        sprintf(scrname, "%s/screenshots/shot%03d.bmp", (settings.GetSettingsDir()).c_str(), num_shots );
        Screenshot(scrname);
        settings.Set( "game.num_shots", num_shots + 1 );
}

void MainPause()
{
        //if (!menu.InMenu() && !multiplay.NumConnected() > 0)
        //if (state.GetGameState() == STATE_PLAYING)
        if( !gui.GetEnabled() && !multiplay.NumConnected() > 0 )
                pauserequest = true;
        /*bool mouse_enabled;
        settings.Get( "mouse.enabled", mouse_enabled );
        if( mouse_enabled )
        {
                gui.MouseReturn();
        }*/
        gui.ProcessAction( "Pause" );
}

void MainUnpause()
{
        unpauserequest = true;
}

// function to handle key press events
void handleKeyPress( SDL_keysym *keysym )
{
        //Vamos_Geometry::Three_Vector tvec1(44.464,-126.8737,0);
        //VERTEX tvec2;
        //QUATERNION trot;

        //if (state.GetGameState() == STATE_MENU)
        //if (menu.InMenu())
        //      menu.MenuKey(keysym->sym);
        //else if (timefactor == 0 && !menu.InMenu()) timefactor = 0;
                //              else timefactor = 1.0;
        if( !gui.GetEnabled() )
        {
                switch ( keysym->sym )
                {
                case SDLK_ESCAPE:
                        // ESC key was pressed
                        //Quit(0);
                        //gui.ChangePage( "InGameMenu" );
                        //menu.MainMenu();
                        esc_pressed = true;
                        break;
                /*case SDLK_F7:
                        
                        tvec1 = tvec1.rotate(0,0,6.21652);
                        cout << tvec1[0] << "," << tvec1[1] << endl;
                
                        
                        tvec2.Set(44.464,-126.8737,0);
                        
                        trot.Rotate(6.21652, 0, 0, 1);
                        tvec2 = trot.RotateVec(tvec2);
                        tvec2.DebugPrint();
                        break;*/
                /*case SDLK_F7:
                        if (timefactor != 100.0f)
                                timefactor = 100.0f;
                        else
                                timefactor = 1.0f;
                        break;*/
                /*case SDLK_PAGEUP:
                        //tmpvert = cam.GetVelocity();
                        cam.MoveRelative(0.0f, 0.0f, -2.0f);
                        //cam.Update();
                        //cam.LoadVelocityIdentity();
                        break;
                case SDLK_PAGEDOWN:
                        //tmpvert = cam.GetVelocity();
                        cam.MoveRelative(0.0f, 0.0f, 2.0f);
                        //cam.Update();
                        //cam.LoadVelocityIdentity();
                        break;*/
                
                //case SDLK_F11:
                        //SDL_WM_ToggleFullScreen( surface );
                        //ChangeDisplay(1280,1024,32,true);
                        //menu.DisplayMenu();//DisplaySelect();
                        //break;
                
                //case SDLK_F12:
                        //menu.MainMenu();
                        //break;

                default:
                        /*if (timefactor == 0.0f)
                                MainUnpause();
                        else
                                keyman.OneTime(keysym->sym);*/
                        break;
                }
        }

        return;
}

void handleKeyRelease( SDL_keysym *keysym )
{
        if( !gui.GetEnabled() )
        {
                switch ( keysym->sym )
                {
                case SDLK_ESCAPE:
                        // ESC key was released
                        if( esc_pressed )
                        {
                                esc_pressed = false;
                                MainPause();
                        }
                        break;
                default:
                        /*if (timefactor == 0.0f)
                                MainUnpause();
                        else*/
                                keyman.OneTime(keysym->sym);
                        break;
                }
        }

        return;
}

void glSetup()
{
        // Enable Texture Mapping ( NEW )
        glEnable( GL_TEXTURE_2D );
        // Enable smooth shading
        glShadeModel( GL_SMOOTH );
        // Set the background black
        //glClearColor( 0.53f, 0.74f, 0.91f, 0.0f );
        glClearColor(0,0,0,0);
        // Depth buffer setup
        glClearDepth( 1.0f );
        // Enables Depth Testing
        glEnable( GL_DEPTH_TEST );
        // The Type Of Depth Test To Do
        glDepthFunc( GL_LEQUAL );
        // Really Nice Perspective Calculations
        glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
        // Enable Lighting
        glEnable( GL_LIGHTING );

        //set the clipping planes
        //glFrustum(1000,1000,1000,1000,1,1000);

        //utility.Tex2D(3, false);
        //utility.Tex2D(2, false);
        //utility.Tex2D(1, false);
        //utility.Tex2D(0, true);
}

//string otrack_file;
//string car_file;
string data_dir;
//int car_paint;

//int number_of_opponents;
//int focused_car;

void SelectCar(string cfile, bool trim)
{       
        //if (clearold)
        world.clear_cars();
        //string car_name;
        //settings.Get( "game.selected_car", car_name );
        //int car_paint;
        //settings.Get( "game.car_paint", car_paint );
        //car_file = cfile;
        state.SetCarName(0, cfile);

        Vamos_Body::Gl_Car* car = 0;
/*      try
        {
*/              car = new Vamos_Body::Gl_Car (Vamos_Geometry::Three_Vector (11.0, 0.0, 0.6));
                car->read (data_dir, cfile);
                car->SetPaint(state.GetCarPaint(0));
                car->chassis ().translate (Vamos_Geometry::Three_Vector(track.GetStart().x, -track.GetStart().z, track.GetStart().y));
                car->chassis ().translate (Vamos_Geometry::Three_Vector (10.0*multiplay.MyNum(), 0.0, 
                                                                                           -car->chassis ().lowest_contact_position () + CAR_Y_OFFSET));
                car->start_engine ();
                car->set_controller(1);
                world.add_car (car);

                /*for (int i = 0; i < number_of_opponents; i++)
                {
                        car = new Vamos_Body::Gl_Car (Vamos_Geometry::Three_Vector (11.0, 0.0, 0.6));
                        car->read (data_dir, cfile);
                        car->chassis ().translate (Vamos_Geometry::Three_Vector (10.0 * (i + 1), 0.0, 
                                -car->chassis ().lowest_contact_position () + CAR_Y_OFFSET));
                        car->start_engine ();
                        car->set_controller(-1);
                        world.add_car (car);
                }*/

                int i;
                //if (!multiplay.Server()) //the client re-loads the world, the server doesn't (NOT TRUE ANYMORE)
                {
                        for (i = 0; i < multiplay.NumConnected()+1; i++)
                        {
                                if (i != multiplay.MyNum())
                                {
                                        int idx = i;
                                        if (idx == 0)
                                                idx = 1;
                                        car = new Vamos_Body::Gl_Car (Vamos_Geometry::Three_Vector (11.0, 0.0, 0.6));
                                        car->read (data_dir, state.GetCarName(idx));
                                        car->SetPaint(state.GetCarPaint(idx));
                                        car->chassis ().translate (Vamos_Geometry::Three_Vector(track.GetStart().x, -track.GetStart().z, track.GetStart().y));
                                        car->chassis ().translate (Vamos_Geometry::Three_Vector (10.0*i, 0.0, 
                                                -car->chassis ().lowest_contact_position () + CAR_Y_OFFSET));
                                        car->start_engine ();
                                        car->set_controller(2);
                                        world.add_car (car);
                                }
                        }
                }

                if (replay.GhostCar())
                {
                        car = new Vamos_Body::Gl_Car (Vamos_Geometry::Three_Vector (11.0, 0.0, 0.6));
                        car->read (data_dir, replay.ReplayCar());
                        car->SetPaint(replay.ReplayPaint());
                        car->chassis ().translate (Vamos_Geometry::Three_Vector (10.0*multiplay.MyNum(), 0.0, 
                                -car->chassis ().lowest_contact_position () + CAR_Y_OFFSET));
                        car->start_engine ();
                        car->set_controller(3);
                        world.add_car (car);
                }

                world.reset();
/*      }
        catch (Vamos_Geometry::XML_Exception& error)
        {
                std::cerr << error.message () << std::endl;
                std::exit (EXIT_FAILURE);
        }
*/
        if (trim)
                ResetWorld(false);
}

bool UnloadWorld()
{
        //these should have error catching such that if they're called before
        // init, it's OK
        //textures.DeleteAll();
        backdrop.DeInit();
//      terrain.DeInit();
        world.DeInit();
        sound.Unload();
        
        return true;
}

#ifdef PATCH_DEBUG
BEZIER * thepatch;
#endif

bool LoadWorld()
{
        UnloadWorld();

        //begin loading world
        timefactor = 1.0;
        
        //reset best lap time
        timer.ResetBest();
        timer.ResetLast();

        LoadingScreen("Loading...\nConfiguration files");

        //state.SetCarName( 0, "" );
        //state.SetCarPaint( 0, 0 );
        //state.SetTrackName( "" );

        string selected_car = "";
        string track_name;
        int car_paint = 0;

        settings.Get( "game.selected_car", selected_car );
        settings.Get( "game.car_paint", car_paint );
        settings.Get( "game.track", track_name );

        //cout << "selected " << track_name << " " << selected_car << endl;
        state.SetCarName( 0, selected_car );
        state.SetCarPaint( 0, car_paint );
        state.SetTrackName( track_name );

        if (state.GetCarName(0) == "")
                state.SetCarName(0, "CS");

        //if (track_name == "")
        //      state.SetTrackName( "ruudskogen" );

        //string world_file = "default-world";
        //string controls_file = "default-controls";
        //number_of_opponents = 0;
        //focused_car = 0;
        //string track_file = "tracks/" + state.GetTrackName() + "/" + state.GetTrackName() + ".xml";
        //world_file = "worlds/" + world_file + ".xml";
        //controls_file = settings.GetSettingsDir() + "/controls/" + controls_file + ".xml";
        data_dir = settings.GetDataDir() + "/";

        /*LoadingScreen("Loading...\nLoading terrain");
        //terrain.Init(2000,200,2000,"outermap3.raw","outermap1-detail.bmp","outermap2-test.png");
        //terrain.Init(2000,200,2000,"shaw4.raw","outermap1-detail.bmp","shawtestmap2.png", REFLECT_RES);
        //terrain.Init(2000,200,2000,"shawlike.raw","detail-lowfreq.bmp","shawlike.png", REFLECT_RES_X, REFLECT_RES_Y);
        //terrain.Init(2000,200,2000,"outermap4.raw","outermap1-detail.bmp","outermap4v1.png");
        string terrainfile;
        string trackpath = settings.GetDataDir() + "/tracks/" + state.GetTrackName() + "/";
        terrainfile = trackpath + "parameters.txt";

        ifstream tf(terrainfile.c_str());
        int numparam, i;
        numparam = 7;
        float param[numparam];
        if (tf)
        {
                for (i = 0; i < numparam; i++)
                        param[i] = utility.fGetParam(tf);
                terrain.Init((int)param[0],(int)param[1],(int)param[2], trackpath+"terrain.png", trackpath+"mask.png", trackpath+"texture.png", trackpath+"detail.png", trackpath+"detail2.png", trackpath+"parametric.png", param[3], param[4], param[5], param[6]);
        }
        else
        {
                cout << "Couldn't find track terrain parameter file " << terrainfile << endl;
                //terrain.Init(3000,300,3000, otrack_file+".png", otrack_file+"-mask.png", otrack_file+".png", otrack_file+"-detail.png", otrack_file+"-detail2.png", otrack_file+"-parametric.png", -1500, -2000, 150, 100);
                param[0] = 3000; param[1] = 300; param[2] = 3000;
                param[3] = -1500;
                param[4] = -2000;
                param[5] = 150;
                param[6] = 100;
                terrain.Init((int)param[0],(int)param[1],(int)param[2], trackpath+"terrain.png", trackpath+"mask.png", trackpath+"texture.png", trackpath+"detail.png", trackpath+"detail2.png", trackpath+"parametric.png", param[3], param[4], param[5], param[6]);
        }

        LoadingScreen("Loading...\nTrack");
        try
        {
                road = new Vamos_Track::Strip_Track;
                road->read (data_dir, track_file);
        }
        catch (Vamos_Geometry::XML_Exception& error)
        {
                std::cerr << error.message () << std::endl;
                std::exit (EXIT_FAILURE);
        }*/

        LoadingScreen("Loading...\nTrack");
        track.Load(state.GetTrackName());
        
        LoadingScreen("Loading...\nLoading backdrop");
        backdrop.Init();
        
        LoadingScreen("Loading...\nLoading scenery objects");
        string objectpath = settings.GetDataDir() + "/tracks/" + state.GetTrackName() + "/objects";
        objects.LoadObjectsFromFolder(objectpath);

        #ifdef COLLISION_TESTING
        if (0)
        {
                bool col = false;
                VERTEX origin, dir, colpt, normal;
                bool closest = true;
                origin.Set(496.334,1000,-1.11335);
                dir.Set(0,-1,0);
                BEZIER * colpatch;
                ROADSTRIP * colstrip;
                ofstream deb;
                deb.open("debug.log");
                deb << "Debug log start" << endl;
                deb.close();
                
                col = track.CollideRoads(origin, dir, colpt, closest, colstrip, colpatch, normal);
                deb.open("debug.log", ofstream::out | ofstream::app);
                deb << "col: " << col << endl;
                deb << "origin: "; origin.DebugPrint(deb);
                deb << "dir: "; dir.DebugPrint(deb);
                deb << "colpt: "; colpt.DebugPrint(deb);
                deb << "closest: " << closest << endl;
                deb << "normal: "; normal.DebugPrint(deb);
                deb << "seglen: " << 10000.0f << endl;
                deb << "-------------" << endl;
                deb.close();
                
                col = objects.Collide(origin, dir, colpt, closest, normal, 10000.0f);
                deb.open("debug.log", ofstream::out | ofstream::app);
                deb << "col: " << col << endl;
                deb << "origin: "; origin.DebugPrint(deb);
                deb << "dir: "; dir.DebugPrint(deb);
                deb << "colpt: "; colpt.DebugPrint(deb);
                deb << "closest: " << closest << endl;
                deb << "normal: "; normal.DebugPrint(deb);
                deb << "seglen: " << 10000.0f << endl;
                deb << "-------------" << endl;
                deb.close();
        }
        #endif
        
        //Quit(0);
        
        LoadingScreen("Loading...\nLoading sound");
        //sound.Deinit();
        //sound.Init();
        sound.Reload();

        LoadingScreen("Loading...\nWorld");
        world.Init(&track);

        LoadingScreen("Loading...\nCar");
        SelectCar(state.GetCarName(0), true);
        //world.GetPlayerCar()->SetPaint(car_paint); <-done in selectcar instead.

        //LoadingScreen("Loading...\nLoading Trees");
        //trees.ReadFromFile(settings.GetFullDataPath("tracks/" + state.GetTrackName() + "/treemap.png"), settings.GetFullDataPath("tracks/" + state.GetTrackName() + "/foliagemap.png"));
        /*trees.DeleteAll();
        int numtrees = 200;
        for (i = 0; i < numtrees/2; i++)
        {
                VERTEX tp;
                tp.x = ((float) rand()/RAND_MAX)*(param[0]/2.0)+param[0]/4.0;
                tp.z = ((float) rand()/RAND_MAX)*(param[2]/2.0)+param[2]/4.0;
                tp.x += param[3];
                tp.z += param[4];
                tp.y = terrain.GetHeight(tp.x, tp.z);
                trees.Add(tp, 40.0, 0, 5);
        }

        for (i = 0; i < numtrees/2; i++)
        {
                VERTEX tp;
                tp.x = ((float) rand()/RAND_MAX)*(param[0]/2.0)+param[0]/4.0;
                tp.z = ((float) rand()/RAND_MAX)*(param[2]/2.0)+param[2]/4.0;
                tp.x += param[3];
                tp.z += param[4];
                tp.y = terrain.GetHeight(tp.x, tp.z);
                trees.Add(tp, 60.0, 1, 5);
        }*/

        timer.Reset();
        particle.Clear();

        LoadingScreen("Loading...\nDone");

        mq1.AddMessage("Simulation start");

        #ifdef PATCH_DEBUG
        {
                VERTEX v[4];
                /*v[0].Set(-2045.29,604.818,-566.924);
                v[1].Set(-2040.08,605.083,-572.898);
                v[2].Set(-2026.6,602.961,-550.628);
                v[3].Set(-2020.85,602.961,-557.449);*/
                v[0].Set(-2148.81,583.537,-1395.68);
                v[1].Set(-2151.04,583.525,-1396.96);
                v[2].Set(-2145.45,583.378,-1401.53);
                v[3].Set(-2147.67,583.341,-1402.81);

                thepatch = track.GetPatch(v);
                if (thepatch != NULL)
                {
                        cout << "Got patch" << endl;
                
                        VERTEX p1,p2;
                        /*p1.Set(-2032.96,603.927,-562.198);
                        p2.Set(-2033,603.931,-562.227);*/
                        p1 = (v[0] + v[1]).ScaleR(0.5);
                        p2 = (v[2] +