#include <a_samp>
/*
    Things To Do

50 Races
    - Car models
    - skin
    - ratio
    - prize

Help Topics
    - Races
    - Diskettes
    - Respawn
    - Recordings

*/
/*
    Player.ini

password
money
level
carmodel
color1
color2
skin
totalraces
mptotalraces
mptotalwins
*/

#define MAX_BOTS 10
#undef MAX_PLAYERS
#define MAX_PLAYERS (100+MAX_BOTS)
#define COLOR_BOT       0x90BB90FF
#define COLOR_WHITE     0x808080FF
#define COLOR_LYELLOW   0xFFFF82FF
#define COLOR_YELLOW    0xFFFF00FF
#define COLOR_LGREEN    0x90EE90FF
#define COLOR_DGREEN    0x006400FF
#define COLOR_GREEN     0xADFF2FFF
#define COLOR_BLUE      0x4169FFFF
#define COLOR_DBLUE     0x000080FF
#define COLOR_LBLUE     0x6495EDFF
#define COLOR_PINK      0xFF1493FF
#define COLOR_LPINK     0xFF69B4FF
#define COLOR_RED       0xDC143CFF
#define COLOR_LRED      0xDC143CFF
#define COLOR_MAROON    0x800000FF
#define COLOR_BROWN     0x8B4513FF
#define COLOR_GREY      0x808080FF
#define COLOR_BLACK     0x808080FF

#define MAX_PLAYBACK_BOTS 10
#define CHECKPOINT_ENTER_SOUND 1138
#define COUNTDOWN_SOUND 1056
#define GO_SOUND 1057
#define DIALOG_CLICK_SOUND 1150
#define DISK_PICK_SOUND 0
#define DISK_SOUND 0
#define QUIT_RACE_SOUND 1053
#define LOST_RACE_SOUND 1055
#define WON_RACE_SOUND 1058
#define LEVEL_UP_SOUND 1183
#define RESPAWN_SOUND 1132
#define BIKE_BOUGHT_SOUND 1149
#define RECORD_SOUND 1185
#define STOP_SOUND  1190
#define PLAY_SOUND 1186

const default_weather = 1337;
new ignordisk[MAX_PLAYERS];
new joined[MAX_PLAYERS];
new Nitrox[MAX_PLAYERS];
const min_players = 2;
const max_counts = 20;
new MPCounter = 0;
new mpRace[MAX_PLAYERS] = 0;
const Float:cpbelow = 1.2;
new File:hbot;
new Finishmp = 0;
new Prizemp[3];
new timetaken = 0;
new DiskP[MAX_PLAYERS];
new SpecMod[MAX_PLAYERS];
new DidUask[MAX_PLAYERS] = -1;
new mp = -1;
new Recording[MAX_PLAYERS];

new Float:FuelStations[][] =
{
    {1004.0070,-939.3102,42.1797},
    {1944.3260,-1772.9254,13.3906},
    {-90.5515,-1169.4578,2.4079},
    {-1609.7958,-2718.2048,48.5391},
    {-2029.4968,156.4366,28.9498},
    {-2408.7590,976.0934,45.4175},
    {-2243.9629,-2560.6477,31.8841},
    {-1676.6323,414.0262,6.9484},
    {2202.2349,2474.3494,10.5258},
    {614.9333,1689.7418,6.6968},
    {-1328.8250,2677.2173,49.7665},
    {70.3882,1218.6783,18.5165},
    {2113.7390,920.1079,10.5255},
    {-1327.7218,2678.8723,50.0625}
};

new Channel[MAX_PLAYERS][128];
new FreeNPC[MAX_BOTS];
enum ecp
{
    ename[23],
    emodel,
    eskin,
    Float:ex1,
    Float:ey1,
    Float:ez1,
    Float:ex2,
    Float:ey2,
    Float:ez2,
    emoney,
    eratio,
    ecolor1,ecolor2,
    ev,
    eid
};

new max_checkpoints;
new pKey[MAX_PLAYERS];
new CPid[MAX_PLAYERS];
new Rc[MAX_PLAYERS][30];
new Text3D:DDD[MAX_PLAYERS];
new Text3D:DDD2[MAX_PLAYERS];
new Text:NitroBar[MAX_PLAYERS];
new Text:SpeedBar[MAX_PLAYERS];

//new PlayerText3D:Dist[MAX_PLAYERS];
new Checkpoints[100][ecp];

new WannaRace[][64] =
{
    {"wroom wroooooom?"},
    {"a challenge?"},
    {"street race?"},
    {"My rides better, doubt it?"},
    {"hey, lets compare? what do you say."},
    {"excuse me, would you like to race me?"},
    {"hey, wanna race?"},
    {"like to race?"},
    {"lets race?"},
    {"yo, would you like to race with me?"}
};

new Race[MAX_PLAYERS];
enum carStats
{
    ename[20],
    emodel,
    ecost,
    elevel,
    etopspeed[6],
    accelaration[6],
    ehandling[6]
};
new Text:WWW;
new Text:HUD;
new pCar[MAX_PLAYERS];
new Purchase[MAX_PLAYERS];
new cars[][carStats] =
{


    { "NONE", 0, 0, 0, "" , "" , "" },
    { "Admiral",445, 1500, 1, "]]", "]]" , "]]]]" },
    { "Elegant",507, 1500, 1, "]]", "]]" , "]]]]" },
    { "Emperor",585, 1500, 1, "]]", "]]" , "]]]]" },
    { "Euros",587, 9500, 3, "]]]]", "]]]]" , "]]]" },
    { "Glendale",466, 1500, 1, "]]", "]]" , "]]]]" },
    { "Intruder",546, 2500, 2, "]]]", "]]]" , "]]]]" },
    { "Merit",551, 2500, 2, "]]]", "]]]" , "]]]]" },
    { "Nebula",516, 2500, 2, "]]]", "]]]" , "]]]]" },
    { "Oceanic",467, 2000, 2, "]]", "]]]" , "]]]]" },
    { "Premier",426, 2500, 2, "]]]", "]]]" , "]]]]" },
    { "Sentinel",405, 1500, 1, "]]", "]]]" , "]]]]" },
    { "Stretch",409, 1600, 1, "]]]", "]]" , "]]]]" },
    { "Sunrise",550, 2500, 2, "]]]", "]]]" , "]]]]" },
    { "Tahoma",566, 2000, 1, "]]]", "]]]" , "]]]]" },
    { "Vincent",540, 1500, 1, "]]", "]]]" , "]]]]" },
    { "Washington",421, 1500, 1, "]]]", "]]" , "]]]]" },
    { "Willard",529, 1500, 1, "]]", "]]]" , "]]]]" },
    { "Alpha",602, 9000, 3, "]]]]", "]]]" , "]]]" },
    { "Blista",496, 2500, 2, "]]]", "]]]" , "]]]]" },
    { "Bravura",401, 2000, 1, "]]]", "]]]" , "]]]]" },
    { "Buccaneer",518, 1700, 1, "]]]", "]]]" , "]]]]" },
    { "Cadrona",527, 2500, 2, "]]]", "]]]" , "]]]]" },
    { "Club",589, 2600, 2, "]]]", "]]]" , "]]]]" },
    { "Esperanto",419, 1500, 1, "]]", "]]]" , "]]]" },
    { "Feltzer",533, 1700, 1, "]]", "]]]" , "]]]" },
    { "Fortune",526, 1700, 1, "]]]", "]]]" , "]]]]" },
    { "Hermes",474, 1500, 1, "]]", "]]" , "]]]" },
    { "Hustler",545, 1500, 1, "]]", "]]" , "]]]" },
    { "Majestic",517, 1700, 1, "]]]", "]]]" , "]]]" },
    { "Picador",600, 1500, 1, "]]", "]]]" , "]]]" },
    { "Stafford",580, 1500, 1, "]]", "]]]" , "]]]" },
    { "Stallion",439, 1600, 1, "]]", "]]]" , "]]]]" },
    { "Tampa",549, 1700, 1, "]]", "]]]" , "]]]]" },
    { "Virgo",491, 1600, 1, "]]]", "]]]" , "]]]]" },
    { "Buffalo",402, 3000, 2, "]]]", "]]" , "]]]" },
    { "Clover",542, 2000, 2, "]]]", "]]]" , "]]]" },
    { "Phoenix",603, 2500, 2, "]]]", "]]]" , "]]]" },
    { "Sabre",475, 2500, 2, "]]]", "]]]" , "]]]" },
    { "Elegy",562, 2700, 2, "]]]", "]]" , "]]]]" },
    { "Flash",565, 2500, 2, "]]]", "]]]" , "]]]]" },
    { "Jester",559, 6000, 3, "]]]]", "]]]" , "]]]" },
    { "Stratum",561, 1700, 1, "]]", "]]]" , "]]]]" },
    { "Sultan",560, 1900, 1, "]]]", "]]]" , "]]]]" },
    { "Uranus",558, 2500, 2, "]]]", "]]]" , "]]]]" },
    { "Banshee",429, 4500, 3, "]]]", "]]]]" , "]]]]" },
    { "Bullet",541, 9000, 3, "]]]]", "]]]]" , "]]]" },
    { "Cheetah",415, 9050, 3, "]]]]", "]]]]" , "]]]" },
    { "Comet",480, 1800, 1, "]]]", "]]]" , "]]]" },
    { "Hotknife",434, 1400, 4, "]]", "]]" , "]]]" },
    { "Hotring A",502, 4000, 4, "]]]", "]]]" , "]]]]" },
    { "Hotring B",503, 4000, 4, "]]]", "]]]" , "]]]]" },
    { "Infernus",411, 7500, 3, "]]]]", "]]]]" , "]]]" },
    { "Super GT",506, 8700, 3, "]]]]", "]]]]" , "]]]" },
    { "Turismo",451, 10000, 3, "]]]]", "]]]]" , "]]]]" },
    { "Windsor",555, 1700, 1, "]]]", "]]]" , "]]]]" },
    { "ZR-350",477, 9500, 3, "]]]]", "]]]]" , "]]]]" },
    { "Blade",536, 2000, 1, "]]]", "]]]" , "]]]]" },
    { "Broadway",575, 1500, 1, "]]", "]]" , "]]]" },
    { "Remington",534, 1500, 1, "]]", "]]]" , "]]]" },
    { "Savanna",567, 2000, 1, "]]]", "]]]" , "]]]]" },
    { "Slamvan",535, 2400, 1, "]]]", "]]]" , "]]" },
    { "Tornado",576, 1600, 1, "]]", "]]]" , "]]]" },
    { "Voodoo",412, 1500, 1, "]]", "]]" , "]]]" },
    { "Bandito",568, 1800, 1, "]]]", "]]]" , "]]]" },
    { "BF Injection",424, 2000, 1, "]]]", "]]]" , "]]]" },
    { "Bloodring Banger",504, 1800, 1, "]]]", "]]]" , "]]]" },
    { "Kart",571, 1900, 1, "]]]", "]]]" , "]]]]" },
    { "Mesa",500, 1600, 1, "]]", "]]" , "]]]]" },
    { "Monster",444, 2500, 4, "]]]", "]]]" , "]]]" },
    { "Monster A",556, 2600, 4, "]]]", "]]]" , "]]]" },
    { "Moster B",557, 2700, 4, "]]]", "]]]" , "]]]" },
    { "Sandking",495, 6500, 4, "]]]]", "]]]" , "]]]]]" }
};

new Text:CarStats[sizeof(cars)];

enum
{

    dLogin,
    dRegister1,
    dRegister2,
    dRegister3,
    dRegistered,
    Car1,
    Car2,
    Car3,
    Car4,
    Car5,
    Car6,
    Car7,
    Car8,
    Car9,
    Car10,
    Car11,
    Car12,
    Car13,
    Car14,
    Car15,
    Car16,
    Car17,
    Car18,
    Car19,
    Car20,
    Car21,
    Car22,
    Car23,
    dPurchase,
    dCant,
    dExit,
    dRace,
    dLost,
    dWon,
    dOk,
    dRec,
    dPlay,
    dRecord,
    dColorize,
    dHelp,
    dChannel,
    dTeleport,
    dWhite,
    dYellow,
    dGreen,
    dBlue,
    dPink,
    dRed,
    dBlack,
    dSubHelp,
    dGoto
};
new CurrentDialog[MAX_PLAYERS];
main()
{
    print("\n------------------------------------------");
    print(" Game: Ride Author: Kapil Date: 24|9|2009");
    print("------------------------------------------\n");
}


Float:getXfromDistance( Float:x  , Float:distance , Float:angle)
{
    new Float:a = 0.017453 * (90-angle);
    new Float:rx;
    rx = floatcos( a )*distance;
    return rx+x;
}

stock Float:findRotation(Float:x1,Float:y1,Float:x2,Float:y2)
{
  new Float:t = -atan2(x2-x1,y2-y1);
  if (t < 0)  t = t + 360.0;
  //printf("%f",t);
  return t;
}

Float:getYfromDistance( Float:y , Float:distance ,Float:angle )
{
    new Float:a = 0.017453 * (90-angle);
    new Float:ry;
    ry = floatsin( a )*distance;
    return ry+y;
}

new Text3D:Disk[MAX_PLAYERS];
new Text:VertiDraw[MAX_PLAYERS];
new GameModeInitiated = 0;

stock LoadRaces()
{
    if(!fexist("races.txt"))
        return 1;
    new File:h = fopen("races.txt",io_read);
    new string[256];
    new str[32],indx;
    new i = 0;
    while(fread(h,string))
    {
        indx = 0;
        str = strtok(string,indx,',');
        if(i != 0)
        if(strcmp(Checkpoints[i-1][ename],str,true)==0)
        {
            i = i - 1;
        }
        format(Checkpoints[i][ename],23,"%s",str);
        i++;
    }
    max_checkpoints = i;
    printf("max checkpoints %d",max_checkpoints);
    i = 0;
    fclose(h);
    h =  fopen("races.txt",io_read);
    while(fread(h,string))
    {
        indx = 0;
        str = strtok(string,indx,',');
        if(i != 0)
        if(strcmp(Checkpoints[i-1][ename],str,true)==0)
        {
            i = i - 1;
        }
        format(Checkpoints[i][ename],23,"%s",str);
        printf("Loading bot %s",str);
        str = strtok(string,indx,',');
        Checkpoints[i][emodel] = strval(str);
        str = strtok(string,indx,',');
        Checkpoints[i][eskin] = strval(str);
        str = strtok(string,indx,',');
        Checkpoints[i][ex1] = floatstr(str);
        str = strtok(string,indx,',');
        Checkpoints[i][ey1] = floatstr(str);
        str = strtok(string,indx,',');
        Checkpoints[i][ez1] = floatstr(str);
        str = strtok(string,indx,',');
        Checkpoints[i][ex2] = floatstr(str);
        str = strtok(string,indx,',');
        Checkpoints[i][ey2] = floatstr(str);
        str = strtok(string,indx,',');
        Checkpoints[i][ez2] = floatstr(str);
        str = strtok(string,indx,',');
        Checkpoints[i][emoney] = strval(str);
        str = strtok(string,indx,',');
        Checkpoints[i][eratio] = strval(str);
        str = strtok(string,indx,',');
        Checkpoints[i][ecolor1] = strval(str);
        str = strtok(string,indx,',');
        Checkpoints[i][ecolor2] = strval(str);
        str = strtok(string,indx,',');
        i++;
    }
    fclose(h);

//  printf("CHECKKING CHECKPOINTS");
    for(i = 0;i < max_checkpoints;i++)
    {
//      printf("%s %f %f %f",Checkpoints[i][ename],Checkpoints[i][ex1],Checkpoints[i][ey1],Checkpoints[i][ez1]);
    }
    LoadBots();

    return 1;
}
public OnGameModeInit()
{
    SetWeather(1337);
    SetWorldTime (12);
    SetTimer("UpdateDisks",6*1000,1);
    SetTimer("RaceManager",15*1000,1);
    SetTimer("UpdateVehicleBots",1*1000,1);

//  printf("OnGameModeInit");
    SetTimer("ManageVehicle",1000,1);
    SetTimer("MultiplayerRaceManagement",10*1000,0);
//  SetTimer("UpdateVelocity",100,1);

    //EnableStuntBonusForAll ( 1 );

    EnableStuntBonusForAll(0);

    ShowPlayerMarkers(2);
    SetNameTagDrawDistance (0);
    ShowPlayerMarkers(1);
    SetGameModeText("My ride my style");

    WWW = TextDrawCreate( 30, 430 , "IAMFASTER.in" );
    TextDrawFont( WWW , 3 );
    TextDrawSetShadow( WWW , 0 );
    TextDrawSetOutline( WWW , 2 );

    HUD = TextDrawCreate( 185, 415 , "Speed:~n~Nitro:" );
    TextDrawFont( HUD , 2 );
    TextDrawSetShadow( HUD , 0 );
    TextDrawSetOutline( HUD , 2 );
    TextDrawLetterSize(HUD,0.25,0.9);

    for(new i = 0;i < MAX_PLAYERS;i++)
    {

        DDD[i] = Create3DTextLabel("0kmph",0xFFFFFFAA,0.0,0.0,0.0,200.0,0);
        DDD2[i] = Create3DTextLabel("Error loading stats",0xFFFFFFAA,0.0,0.0,0.0,15.0,0);

        VertiDraw[i] = TextDrawCreate(400, 390, "This is a message box." );
        TextDrawFont( VertiDraw[i] , 1);
        TextDrawSetShadow( VertiDraw[i] , 0);
        TextDrawUseBox( VertiDraw[i] , 1 );
        TextDrawBoxColor(VertiDraw[i],0x000000AA);
        TextDrawTextSize( VertiDraw[i] , 620 , 480 );
        TextDrawLetterSize(VertiDraw[i],0.25,0.9);
        TextDrawSetOutline( VertiDraw[i] , 1);

        NitroBar[i] = TextDrawCreate( 220 , 420 , "~g~llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll" );
        TextDrawFont( NitroBar[i] , 1);
        TextDrawSetShadow( NitroBar[i] , 0);
        TextDrawLetterSize(NitroBar[i],0.15,2);

        SpeedBar[i] = TextDrawCreate( 220 , 408 , "~r~llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll" );
        TextDrawFont( SpeedBar[i] , 1);
        TextDrawSetShadow( SpeedBar[i] , 0);
        TextDrawLetterSize(SpeedBar[i],0.15,2);

    }


    // Player Class's
    AddPlayerClass(254,1958.3783,1343.1572,15.3746,0.0,0,0,0,0,-1,-1);
    AddPlayerClass(255,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(256,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(257,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(258,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(259,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(260,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(261,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(262,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(263,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(264,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(274,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(275,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(276,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);

    AddPlayerClass(1,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(2,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(290,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(291,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(292,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(293,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(294,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(295,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(296,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(297,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(298,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(299,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);

    AddPlayerClass(277,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(278,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(279,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(288,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(47,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(48,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(49,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(50,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(51,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(52,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(53,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(54,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(55,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(56,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(57,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(58,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(59,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(60,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(61,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(62,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(63,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(64,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(66,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(67,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(68,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(69,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(70,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(71,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(72,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(73,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(75,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(76,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(78,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(79,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(80,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(81,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(82,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(83,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(84,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(85,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(87,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(88,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(89,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(91,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(92,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(93,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(95,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(96,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(97,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(98,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(99,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(100,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(101,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(102,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(103,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(104,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(105,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(106,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(107,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(108,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(109,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(110,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(111,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(112,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(113,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(114,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(115,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(116,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(117,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(118,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(120,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(121,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(122,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(123,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(124,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(125,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(126,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(127,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(128,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(129,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(131,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(133,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(134,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(135,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(136,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(137,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(138,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(139,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(140,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(141,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(142,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(143,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(144,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(145,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(146,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(147,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(148,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(150,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(151,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(152,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(153,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(154,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(155,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(156,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(157,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(158,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(159,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(160,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(161,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(162,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(163,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(164,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(165,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(166,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(167,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(168,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(169,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(170,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(171,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(172,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(173,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(174,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(175,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(176,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(177,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(178,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(179,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(180,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(181,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(182,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(183,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(184,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(185,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(186,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(187,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(188,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(189,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(190,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(191,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(192,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(193,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(194,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(195,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(196,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(197,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(198,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(199,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(200,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(201,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(202,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(203,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(204,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(205,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(206,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(207,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(209,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(210,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(211,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(212,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(213,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(214,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(215,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(216,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(217,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(218,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(219,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(220,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(221,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(222,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(223,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(224,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(225,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(226,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(227,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(228,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(229,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(230,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(231,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(232,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(233,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(234,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(235,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(236,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(237,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(238,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(239,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(240,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(241,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(242,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(243,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(244,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(245,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(246,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(247,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(248,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(249,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(250,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(251,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(253,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(254,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);
    AddPlayerClass(255,1958.3783,1343.1572,15.3746,269.1425,0,0,0,0,-1,-1);

    DisableInteriorEnterExits();
    //SetWeather( 1337 );

    for(new i = 1; i < sizeof(cars);i++)
    {
        AddStaticVehicle( cars[i][emodel] , 404.0320,2450.8276,16.0675 , 0 , -1 , -1  );
        new j =i-1;
        new string[256];
        format(string,256,"Name: %s~n~Price: $%d~n~Top Speed: %s~n~Accelaration: %s~n~Handling: %s~n~Level: %d",cars[i][ename],cars[i][ecost],cars[i][etopspeed],cars[i][accelaration],cars[i][ehandling],cars[i][elevel]);
        CarStats[j] = TextDrawCreate( 30 , 200 , string);
        TextDrawSetShadow(CarStats[j],0);
        TextDrawFont(CarStats[j],0);
        TextDrawSetOutline(CarStats[j],1);
        TextDrawUseBox(CarStats[j],1);
        TextDrawBoxColor(CarStats[j] , 0x000000AA );
        TextDrawTextSize(CarStats[j],183,1);
    }

    LoadRaces();

    for(new  i = 0;i < MAX_BOTS;i++)
    {
        FreeNPC[i] = 1;
        new str[64];
        format(str,64,"BotBot%d",i);
        ConnectNPC(str,"JaControl");
    }
/// printf("OnGamemodeInit Ended");
    GameModeInitiated = 1;
    return 1;
}

npcIgnored(name[])
{
    if(!fexist("IgnoreList.txt"))
        return 0;
    new File:h = fopen("IgnoreList.txt",io_read);
    new string[256];
    while(fread(h,string))
    {
        if(com(string,name)==0)
            return 1;
    }
    fclose(h);
    return 0;
}

ignoreNPC( name[] )
{
    new File:h = fopen("IgnoreList.txt",io_append);
    new string[256];
    format(string,256,"%s\r\n",name);
    fwrite(h,string);
    fclose(h);
}

forward LoadBots();
public LoadBots()
{

    for(new i = 0;i < max_checkpoints;i++)
    {
//      printf("%d %d",max_checkpoints,i);
//          printf("Connecting %s",Checkpoints[i][ename]);
        new Float:rot;
//      ConnectNPC(Checkpoints[i][ename],"JaControl");
        rot = findRotation( Checkpoints[i][ex1],Checkpoints[i][ey1],Checkpoints[i][ex2],Checkpoints[i][ey2]);
        Checkpoints[i][ev] = CreateVehicle( Checkpoints[i][emodel] , Checkpoints[i][ex1] , Checkpoints[i][ey1] , Checkpoints[i][ez1], rot , Checkpoints[i][ecolor1], Checkpoints[i][ecolor2] , 0 );
        for(new j = 0;j <= 13;j++)
        {
            new t = strval(cbGet( i , j+1 ));
            if(t)
                AddVehicleComponent(Checkpoints[i][ev],t);
        }
        ChangeVehiclePaintjob(Checkpoints[i][ev],strval(cbGet(i,15))-1);
    }
}

forward TryConnect(i);
public TryConnect(i)
{
    static tries = 0;
    if(joined[i] != 1)
    {
        if(tries > 10)
            GameModeExit();
        tries++;
//      ConnectNPC(Checkpoints[i][ename],"JaControl");
        SetTimerEx("TryConnect",100,0,"i",i);
    }
    else if(i+1 < max_checkpoints)
    {
        tries = 0;
        SetTimerEx("TryConnect",100,0,"i",++i);
    }
//  printf("try %d",i);
}


public OnGameModeExit()
{
    for(new  i = 0;i < MAX_PLAYERS;i++)
    {
        TextDrawDestroy( VertiDraw[i] );
        TextDrawDestroy( NitroBar[i] );
        TextDrawDestroy( SpeedBar[i] );
        Delete3DTextLabel (DDD[i]);
        Delete3DTextLabel (DDD2[i]);
    }
    for(new i = 0;i < sizeof(cars);i++)
        TextDrawDestroy( CarStats[i] );
    TextDrawDestroy( WWW );
    TextDrawDestroy( HUD );
//  printf("OnGameModeExit");
    return 1;
}
new PlayerSpawned[MAX_PLAYERS];

forward Spawn( playerid );
public Spawn( playerid )
{
    SpawnPlayer(playerid);
    if(PlayerSpawned[ playerid ] == 0 )
        SetTimerEx("Spawn",100,0,"i",playerid );
}
public OnPlayerRequestClass(playerid, classid)
{
//  printf("OnPlayerRequestClass %d %d",playerid, classid);
    if(pExist(playerid))
    {
        Spawn(playerid);
        TogglePlayerControllable( playerid , 0 );
        SetPlayerCameraPos( playerid ,-1893.8807,102.3724,37.7039+350);
        SetPlayerCameraLookAt( playerid , -1893.8807,102.3724+500,37.7039 );
    }
    else
    {
        SetPlayerPos(playerid,1984.4445,157.9501,55.9384);
        SetPlayerCameraPos(playerid,1984.4445,160.9501,55.9384);
        SetPlayerCameraLookAt(playerid,1984.4445,157.9501,55.9384);
        SetPlayerFacingAngle(playerid,0.0);
        TogglePlayerControllable( playerid , 0 );
    }
    return 1;
}

GetCheckpointId( playerid )
{
    for(new i = 0;i < max_checkpoints;i++)
    {
        new name[23];
        GetPlayerName(playerid,name,23);
        if(strcmp(name,Checkpoints[i][ename],true)==0)
            return i;
    }
    printf("GetCheckpointID %d");
    return 0;
}
stock CLS(playerid)
{
    for(new i = 0;i < 60;i++)
        SendClientMessage(playerid,0," ");
}
new alerts[MAX_PLAYERS] = 1;
public OnPlayerConnect(playerid)
{
    new string[256],name[23];
    GetPlayerName(playerid,name,23);
    format(string,256,"%s joined the server.",name);
    for(new i =0;i < MAX_PLAYERS;i++)
        if(IsPlayerConnected(i))
            if(!IsPlayerNPC(i))
            {
                Message(i,string);
            }

    alerts[playerid] = 1;
    if(IsPlayerNPC(playerid))
    {
        for(new i = 0;i < max_checkpoints;i++)
        {
            GetPlayerName(playerid,name,23);
            if(strcmp(name,Checkpoints[i][ename],true)==0)
            {
                Checkpoints[i][eid] = playerid;
//              printf(" Bot %d is %d",i,playerid);
            }
        }
        SetPlayerColor(playerid,GetPlayerColorFromCarColor( Checkpoints[GetCheckpointId(playerid)][ecolor1] ));
    }
    format(Channel[playerid],128,"Global");




//  if(playerid < max_checkpoints)
//  if(IsPlayerNPC(playerid))
//      LoadBots();
    Race[playerid] = -1;
    PlayerSpawned[playerid] = 0;
    CPid[playerid] = -1;
    DidUask[playerid] = -1;
    Recording[playerid] = 0;
    pCar[playerid]=0;
    ignordisk[playerid] = 0;
    DiskP[playerid] = -1;
//  printf("OnPlayerConnect %d",playerid);

    if(IsPlayerNPC(playerid))
    {
        Attach3DTextLabelToVehicle(DDD[playerid],Checkpoints[GetCheckpointId(playerid)][ev],0,0,0);
        Attach3DTextLabelToPlayer(DDD2[playerid],playerid,0,0,0);
    }
    if(IsPlayerNPC(playerid))
    {
        static bots = 1;
//      printf("Bot Count: %d",bots++);
    }
//  SetPlayerArmour(playerid,75);
    return 1;
}

public OnPlayerDisconnect(playerid, reason)
{
    new string[256];
    new name[23];
    GetPlayerName(playerid,name,23);
    format(string,256,"%s left the server.",name);
    for(new i =0;i < MAX_PLAYERS;i++)
        if(IsPlayerConnected(i))
            if(!IsPlayerNPC(i))
            {
                Message(i,string);
            }
    if(Race[playerid] != -1)
        PlayerLost(playerid,Race[playerid]);
    if(mpRace[playerid] == 1)
    {
        mpRace[playerid] = 0;
        new temp = 0;
        for(new i = 0;i < MAX_PLAYERS;i++)
        {
            if(mpRace[i] == 1)
                temp++;
        }
        if(temp < 1)
        {
            mp = -1;
            MultiplayerRaceManagement();
        }
        DisablePlayerRaceCheckpoint( playerid );
    }
//  printf("OnPlayerDisconnect %d %d",playerid, reason);
    if(pExist(playerid))
    {
        if(strval(pGet(playerid,4))==0)
        {
            pRemove(playerid);
            return 1;
        }
        new m = GetPlayerMoney( playerid );
        if(m)
        {
            new str[30];
            valstr(str,m);
            pSet( playerid , 2 , str );
        }
        new s[10];
        valstr(s,GetPlayerWantedLevel(playerid));
        pSet(playerid,22,s);
    }

    DestroyVehicle( pCar[playerid] );
    return 1;
}

public OnPlayerSpawn(playerid)
{

//  printf("OnPlayerSpawn %d",playerid);
    PlayerSpawned[playerid] = 1;
    if(SpecMod[playerid] == 0)
    {
        if(IsPlayerNPC(playerid))
        {
            SetPlayerVirtualWorld(playerid,8900);
            if(playerid < max_checkpoints)
            {
                //new name[23];
                //GetPlayerName(playerid,name,23);
                //new c = GetCheckpoint(name);
                //SetPlayerSkin( playerid , Checkpoints[c][eskin]);
                //GivePlayerMoney(playerid,1000000 + random(999999999));
            }
            else
            {
                SetPlayerVirtualWorld(playerid,9898);
            }
        }
        else
        {
            SetPlayerCameraPos( playerid ,-1893.8807,102.3724,37.7039+350);
            SetPlayerCameraLookAt( playerid , -1893.8807,102.3724+500,37.7039 );

            if(!pExist(playerid))
            {
                OnPlayerJoin( playerid , 0 );
                return 1;
            }
            else
            {
                OnPlayerJoin( playerid , 1 );
            }
            SetPlayerSkin(playerid,strval(pGet(playerid,7)));
        }
    }
    else
    {
        SpecMod[playerid] = 0;
        PutPlayerInVehicle(playerid ,pCar[playerid],0);
    }
    return 1;
}

public OnPlayerDeath(playerid, killerid, reason)
{
//  printf("OnPlayerDeath %d %d %d",playerid, killerid , reason );
    return 1;
}

public OnVehicleSpawn(vehicleid)
{
//  printf("OnVehicleSpawn %d ",vehicleid);
    return 1;
}

public OnVehicleDeath(vehicleid, killerid)
{
//  printf("OnVehicleDeath %d %d ",vehicleid,killerid);
    return 1;
}

stock GetCheckpoint(name[])
{
    for(new i = 0;i < max_checkpoints;i++)
            if(com(name,Checkpoints[i][ename])==0)
            {
                return i;
            }

    return -1;
}

Float:GetDistanceBetweenPlayers(p1,p2)
{
    new Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2;
    if(!IsPlayerConnected(p1) || !IsPlayerConnected(p2))
    {
        return -1.00;
    }
    GetPlayerPos(p1,x1,y1,z1);
    GetPlayerPos(p2,x2,y2,z2);
    return floatsqroot(floatpower(floatabs(floatsub(x2,x1)),2)+floatpower(floatabs(floatsub(y2,y1)),2)+floatpower(floatabs(floatsub(z2,z1)),2));
}

Float:GetDistance(Float:x1,Float:y1,Float:z1,Float:x2,Float:y2,Float:z2)
{
    return floatsqroot(floatpower(floatabs(floatsub(x2,x1)),2)+floatpower(floatabs(floatsub(y2,y1)),2)+floatpower(floatabs(floatsub(z2,z1)),2));
}

stock GetClosestBot( playerid )
{
    new Float:C=99999.9999,c = -1;
    new i;
    for(i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerConnected(i))
        if(IsPlayerNPC( i ))
        {
            new Float:t = GetDistanceBetweenPlayers(i,playerid);
            if(t < C)
            {
                C = t;
                c = i;
            }
        }
    }
    return c;
}

stock StartRace(playerid)
{
    new str[23];
    new bot = DidUask[playerid];
    GetPlayerName(bot,str,23);
    //printf("---------- %d %s",bot,str);
    new c = GetCheckpoint(str);
    if(c != -1)
    {
        Race[playerid] = bot;
        new string[30];
        format(string,30,"go %s",str);
        SendClientMessage(bot,0,string);
        //SetPlayerRaceCheckpoint( playerid , 2 , Checkpoints[c][ex2],Checkpoints[c][ey2],Checkpoints[c][ez2],0,0,0,5);
        SetPlayerRaceCheckpoint( bot , 2 , Checkpoints[c][ex2],Checkpoints[c][ey2],Checkpoints[c][ez2]-cpbelow,0,0,0,15);
    }
}
new mute[MAX_PLAYERS];

public OnPlayerText(playerid, text[])
{

//  printf("OnPlayerText %d %s",playerid, text);
    if(mute[playerid] == 1)
        return 0;
    if(!PlayerSpawned[playerid])
        return 0;
    if(text[0] == '@')
    {
        for(new i = 0;i < MAX_PLAYERS;i++)
        {
            if(IsPlayerConnected(i))
                if(!IsPlayerNPC(i))
                    if(isadmin(i))
                        if(PlayerSpawned[i])
                            SendPlayerMessageToPlayer(i,playerid,text);
        }
        return 0;
    }


    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerConnected(i))
            if(!IsPlayerNPC(i))
                if(strcmp(Channel[playerid],Channel[i],true)==0)
                        if(PlayerSpawned[i])
                            SendPlayerMessageToPlayer(i,playerid,text);
    }
    return 0;
}

stock GetXYInfrontOfMe(v,Float:distance, &Float:x, &Float:y)
{
    new Float:z, Float:angle;
    GetVehiclePos(v,x,y,z);
    GetVehicleZAngle(v,angle);
    x += (distance * floatsin(-angle, degrees));
    y += (distance * floatcos(-angle, degrees));
}

stock GetXYbehindPlayer(v,Float:distance, &Float:x, &Float:y)
{
    new Float:z, Float:angle;
    GetVehiclePos(v,x,y,z);
    GetVehicleZAngle(v,angle);
    angle = angle + 180;
    x += (distance * floatsin(-angle, degrees));
    y += (distance * floatcos(-angle, degrees));
}

enum DiskTypes
{
    blind,
    skid,
    snail,
    reverse,
    bounce,
    blast,
    drunk,
    storm,
    rain,
    jump,
    fog,

};

new DiskTypes:DiskT[MAX_PLAYERS];
forward DeleteDisk(playerid);
public DeleteDisk( playerid )
{
    if(Disk[playerid])
        Delete3DTextLabel( Disk[playerid] );
    if(DiskP[playerid])
        DestroyPickup( DiskP[playerid] );
    DiskP[playerid] = -1;
}

stock CreateDisk( playerid )
{
    new Float:x,Float:y,Float:z;
    new v = GetPlayerVehicleID(playerid);
    GetVehiclePos(v,x,y,z);
    GetXYInfrontOfMe( v , 30 , x , y );
    x = x + float(random(5));
    y = y + float(random(5));
    new r = random(11);
//  DeleteDisk(playerid);


    if(r == 0) // here
    {
        DiskT[playerid] = blind;
        Disk[playerid] = Create3DTextLabel("+ blind",0xFFFFFFAA,x,y,z,30,0);
    }
    else if(r == 1)
    {
        DiskT[playerid] = skid;
        Disk[playerid] = Create3DTextLabel("+ skid",0xFFFFFFAA,x,y,z,30,0);
    }
    else if(r == 2)
    {
        DiskT[playerid] = snail;
        Disk[playerid] = Create3DTextLabel("+ snail",0xFFFFFFAA,x,y,z,30,0);
    }
    else if(r == 3)
    {
        DiskT[playerid] = reverse;
        Disk[playerid] = Create3DTextLabel("+ reverse",0xFFFFFFAA,x,y,z,30,0);
    }
    else if(r == 4)
    {
        DiskT[playerid] = bounce;
        Disk[playerid] = Create3DTextLabel("+ bounce",0xFFFFFFAA,x,y,z,30,0);
    }
    else if(r == 5)
    {
        DiskT[playerid] = blast;
        Disk[playerid] = Create3DTextLabel("+ blast",0xFFFFFFAA,x,y,z,30,0);
    }
    else if(r == 6)
    {
        DiskT[playerid] = drunk;
        Disk[playerid] = Create3DTextLabel("+ drunk",0xFFFFFFAA,x,y,z,30,0);
    }
    else if(r == 7)
    {
        DiskT[playerid] = storm;
        Disk[playerid] = Create3DTextLabel("+ storm",0xFFFFFFAA,x,y,z,30,0);
    }
    else if(r == 8)
    {
        DiskT[playerid] = jump;
        Disk[playerid] = Create3DTextLabel("+ jump",0xFFFFFFAA,x,y,z,30,0);
    }
    else if(r == 9)
    {
        DiskT[playerid] = fog;
        Disk[playerid] = Create3DTextLabel("+ fog",0xFFFFFFAA,x,y,z,30,0);
    }
    else if(r == 10)
    {
        DiskT[playerid] = rain;
        Disk[playerid] = Create3DTextLabel("+ rain",0xFFFFFFAA,x,y,z,30,0);
    }
    DiskP[playerid] = CreatePickup(0,14,x,y,z);
    SetTimerEx("DeleteDisk",4000,0,"i",playerid);
}

new Make[MAX_PLAYERS];
new timerforcp;




public OnPlayerCommandText(playerid, cmdtext[])
{
//      printf("OnPlayerCommandText %d %s",playerid,cmdtext);
    if(!PlayerSpawned[playerid])
        return 0;
    if(strcmp("/help",cmdtext,true,5)==0)
        Message(playerid,"There arn't any commands available. Press 2.");

    new cmd[25];
    new indx;
    cmd = strtok(cmdtext, indx);
    if(isadmin(playerid))
    {
        if(com("/newrace",cmd,true)==0)
        {
            if(ignordisk[playerid] == 1)
                return 1;
            ignordisk[playerid] = 1;
            cmd = strtok(cmdtext,indx);
            if(strlen(cmd))
            {
                new File:h = fopen( "races.txt" , io_append);
                new string[256];
                new Float:x,Float:y,Float:z;
                GetPlayerPos(playerid,x,y,z);

                format(string,256,"\r\n%s , 411 , 0 , %f , %f , %f , ",cmd,x,y,z);
                fwrite(h,string);
                fclose(h);
                Make[playerid] = 1;
                timerforcp = SetTimerEx("RecordRaceCheckpoint",4000,1,"is",playerid,cmd);
                StartRecordingPlayerData(playerid,1,cmd);

                Message(playerid,"Recording Started.");
                PlayerPlaySound(playerid,RECORD_SOUND,0,0,0);
            }

            return 1;
        }
        if(com("/kick",cmd,true)==0)
        {
            cmd = strtok(cmdtext, indx);
            if(strlen(cmd))
            {
                if(!isadmin(strval(cmd)))
                    if(!IsPlayerNPC(strval(cmd)))
                        Kick(strval(cmd));
            }
            return 1;
        }
        if(com("/ban",cmd,true)==0)
        {
            cmd = strtok(cmdtext, indx);
            if(strlen(cmd))
            {
                if(!isadmin(strval(cmd)))
                    if(!IsPlayerNPC(strval(cmd)))
                        Ban(strval(cmd));
            }
            return 1;
        }
        if(com("/freeze",cmd,true)==0)
        {
            cmd = strtok(cmdtext, indx);
            if(strlen(cmd))
            {
                if(!isadmin(strval(cmd)))
                    if(!IsPlayerNPC(strval(cmd)))
                        TogglePlayerControllable(strval(cmd),0);
            }
            return 1;
        }
        if(com("/unfreeze",cmd,true)==0)
        {
            cmd = strtok(cmdtext, indx);
            if(strlen(cmd))
            {
                if(!isadmin(strval(cmd)))
                    if(!IsPlayerNPC(strval(cmd)))
                        TogglePlayerControllable(strval(cmd),1);
            }
            return 1;
        }

        if(com("/mute",cmd,true)==0)
        {
            cmd = strtok(cmdtext, indx);
            if(strlen(cmd))
            {
                if(!isadmin(strval(cmd)))
                    if(!IsPlayerNPC(strval(cmd)))
                        mute[strval(cmd)] = 1;
            }
            return 1;
        }
        if(com("/unmute",cmd,true)==0)
        {
            cmd = strtok(cmdtext, indx);
            if(strlen(cmd))
            {
                if(!isadmin(strval(cmd)))
                    if(!IsPlayerNPC(strval(cmd)))
                        mute[strval(cmd)] = 0;
            }
            return 1;
        }

        if(com("/alerts",cmd,true)==0)
        {
            cmd = strtok(cmdtext, indx);
            if(strlen(cmd))
            {
                alerts[playerid] = strval(cmd);
            }
            return 1;
        }

        if(com("/list",cmd,true)==0)
        {
            SendClientMessage(playerid,0xFFFFFFAA,"@<chat>/kick/ban/mute/unmute/freeze/unfreeze/alerts <0/1>");
            return 1;
        }


        if(!IsPlayerAdmin(playerid))
            return 1;
    }
    if(!IsPlayerAdmin(playerid))
    {
        //SetPlayerChatBubble(playerid,cmdtext[1],GetPlayerColor(playerid),10,6 * 1000);
        return 1;
    }


    if(com("/addadmin",cmd)==0)
    {
        if(IsPlayerAdmin(playerid))
        {
            cmd = strtok(cmdtext,indx);
            addadmin( cmd );
        }
    }
    if(com("/deladmin",cmd)==0)
    {
        if(IsPlayerAdmin(playerid))
        {
            cmd = strtok(cmdtext,indx);
            deladmin( cmd );
        }
    }
    if(com("/mp",cmdtext)==0)
        MultiplayerRaceManagement();

    if (com("/shop", cmdtext) == 0)
    {
        if((GetPlayerVirtualWorld(playerid)==0) && (Race[playerid] == -1) && (mpRace[playerid] != 1))
            Shop( playerid );
        return 1;
    }


    if(com("/respawn",cmdtext,true)==0)
    {
        if((GetPlayerVirtualWorld(playerid)==0) && (Race[playerid] == -1) && (mpRace[playerid] != 1))
            SpawnCar( playerid );
        return 1;
    }

    if(com("/ignore",cmd,true)==0)
    {
        if(IsPlayerAdmin(playerid))
        {
            cmd = strtok(cmdtext,indx);
            if(strlen(cmd))
            {
                ignoreNPC( cmd );
            }
        }
        return 1;
    }


    if(com("/weather",cmd,true)==0)
    {
        cmd = strtok(cmdtext,indx);
        SetPlayerWeather(playerid,strval(cmd));
    }
    if(com("/goto",cmd,true)==0)
    {
        cmd = strtok(cmdtext,indx);

        new i = strval(cmd);
        SetVehiclePos(pCar[playerid],Checkpoints[i][ex1],Checkpoints[i][ey1],Checkpoints[i][ez1]);


    }

    if(com("/xplod",cmd,true)==0)
    {
        new Float:x,Float:y,Float:z;
        GetVehiclePos(GetPlayerVehicleID(playerid),x,y,z);
        new t = strval(strtok(cmdtext,indx));
        new Float:a = floatstr(strtok(cmdtext,indx));
        CreateExplosion(x,y,z,t,a);
    }


    if(com("/disk",cmdtext,true)==0)
        CreateDisk( playerid);

    if(com("/draw",cmd,true)==0)
    {
        Message(playerid,cmdtext);
    }
    if(com("/drunk",cmd,true)==0)
    {
        cmd = strtok(cmdtext,indx);
        SetPlayerDrunkLevel(playerid,strval(cmd));
    }
    if(com("/record",cmd,true)==0)
    {
        cmd = strtok(cmdtext,indx);
        if(strlen(cmd))
        {
            new string[256];
            format(string,256,"%s\n%s\n%s\n%s\n%s",cGet( playerid , 1 ),cGet( playerid , 2 ),cGet( playerid , 3 ),cGet( playerid , 4 ),cGet( playerid , 5 ));
            format(Rc[ playerid ],30,"%s",cmd);
            ShowDialog( playerid , dRec , 2 ,"Record", string,"Ok","Cancel");
        }
        else
        {
            ShowDialog( playerid , dCant , 0 ,"Record", "You have to enter a name for the record.\nUsage: /record <record name>.","Ok","Cancel");
        }
        return 1;
    }
    if(com("/play",cmd,true)==0)
    {
        new string[256];
        format(string,256,"%s\n%s\n%s\n%s\n%s",cGet( playerid , 1 ),cGet( playerid , 2 ),cGet( playerid , 3 ),cGet( playerid , 4 ),cGet( playerid , 5 ));
        ShowDialog( playerid , dPlay , 2 ,"Playback", string,"Ok","Cancel");
        return 1;
    }
    if(com("/stop",cmd,true)==0)
    {
        if(GetPlayerVirtualWorld(playerid) == 0)
            stoprecord( playerid );
        if(GetPlayerVirtualWorld(playerid) > 1)
        {
            stopspectate( playerid );
        }
        return 1;
    }

    if(com("/flip",cmdtext,true)==0)
    {
        new v = GetPlayerVehicleID(playerid);
        new Float:Z;
        GetVehicleZAngle(v,Z);
        SetVehicleZAngle( v,Z);
        return 1;
    }



    return 0;
}

stock play( playerid, rec[] )
{
    new id = guesswhosnext();
    SetPlayerVirtualWorld(id,0);
    if(id == -1)
    {
        ShowDialog( playerid , dCant , 0 , "Error" , "Unable to load playback mode. Try again after some time.","Ok","Cancel");
    }
    else
    {
        new r[30];
        new name[23];
        GetPlayerName(playerid,name,23);
        new f; // check if f lies between 1 - 5
        for(f = 1;f <= 5;f++)
            if(com(cGet(playerid,f),rec)==0)
                break;
        format(r,30,"%sx%d.rec",name,f);

        if(fexist(r))
        {
            format(r,30,"%sx%d",name,f);
            SpecMod[playerid] = 1;

            //printf("guessed id %d",id);
            new v = CreateVehicle( strval(rGet( playerid , f , 4 )) ,100000,100000,100000,0,strval(rGet( playerid , f , 5 )),strval(rGet( playerid , f , 6)),-1);

            new Float:x = floatstr(rGet( playerid , f , 1 ));
            new Float:y = floatstr(rGet( playerid , f , 2 ));
            new Float:z = floatstr(rGet( playerid , f , 3 ));
            SetVehiclePos(v,x,y,z);
            TogglePlayerSpectating( playerid , 1 );
            Message(playerid,"Loading please wait...");
            SetTimerEx("play2",2000,0,"iiis",playerid,id,v,r);
            //tick180(playerid,180);
            PlayerPlaySound(playerid,PLAY_SOUND,0,0,0);
        }
        else
        {
            ShowDialog( playerid , dCant , 0 , "Error" , "File not found.","Ok","Cancel");
        }
    }
}

forward play2(playerid,id,v,r[]);
public play2(playerid,id,v,r[])
{
    SetPlayerSkin(id,   GetPlayerSkin(playerid));
    PutPlayerInVehicle(id,v,0);
    SetPlayerVirtualWorld(id,1+id);
    SetVehicleVirtualWorld(v,1+id);
    SetPlayerVirtualWorld(playerid,1+id);
//    TogglePlayerControllable(playerid,0);
    PlayerSpectatePlayer( playerid , id  );
//  PutPlayerInVehicle(playerid,v,1);
    new string[64];
    format(string,64,"play %s",r);
    Message(playerid,"Press ENTER to stop.");
    SendClientMessage(id,0,string);
}

stock stopspectate( playerid )
{
//  TogglePlayerControllable(playerid,1);
    new s = GetPlayerSkin(playerid);
    TogglePlayerSpectating(playerid,0);
    SendClientMessage(GetPlayerVirtualWorld(playerid)-1,0,"stop");
    SetPlayerVirtualWorld(playerid,0);
    DestroyVehicle( GetPlayerVirtualWorld(playerid)-1 );
    RemovePlayerFromVehicle( GetPlayerVirtualWorld(playerid)-1 );
    SetPlayerSkin(playerid,s);
//  DestroyVehicle( pCar[playerid] );
}

forward stoprecord( playerid );
public stoprecord( playerid )
{
    Message(playerid , "Recording Saved.");
    PlayerPlaySound(playerid,STOP_SOUND,0,0,0);
    StopRecordingPlayerData( playerid );
    Recording[playerid] = 0;

}

stock record( playerid , index , cmd[] )// cmd is record name
{
        cSet( playerid , index , cmd );
        new f = index;
        rRegister( playerid , f );
        new string[32];

        new v = GetPlayerVehicleID(playerid);
        new Float:x,Float:y,Float:z;
        GetVehiclePos(v,x,y,z);
        format(string,32,"%f",x);
        rSet( playerid ,  f ,1,  string );
        format(string,32,"%f",y);
        rSet( playerid ,  f ,2,  string );
        format(string,32,"%f",z);
        rSet( playerid ,  f ,3,  string );
        format(string,32,"%d",GetVehicleModel(v));
        rSet( playerid ,  f ,4,  string );
        new c = strval(pGet(playerid,5));
        format(string,32,"%d",c );
        rSet( playerid ,  f ,5, string );
        c = strval(pGet(playerid,6));
        format(string,32,"%d",c);
        rSet( playerid ,  f ,6,  string );
        new name[23];
        GetPlayerName(playerid,name,23);
        format(string,32,"%sx%d",name,f);
        StartRecordingPlayerData( playerid , 1 , string);
        Message(playerid ,  "Recording Started. Press ENTER to stop.");
        Recording[playerid] = 1;
        SetTimerEx("stoprecord",3 * 60 * 1000,0,"i",playerid);
        //tick180(playerid,180);
}

forward tick180(i,time);
public tick180(i,time)
{
    if(time <= 180)
    {
        new st[10];
        new s,m;
        s = time % 60;
        m = time / 60;
        format(st,10,"%d:%d",m,s);
        GameTextForPlayer(i,st,1000,5);
        SetTimerEx("tick180",1000,0,"ii",i,--time);
    }
}

stock guesswhosnext()
{
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        new name[15];
        GetPlayerName(i,name,15);
        new str[15];
        for(new j = 0;j < MAX_PLAYBACK_BOTS;j++)
        {
            format(str,15,"BotBotBot%d",j);
            if(com(name,str)==0)
            {
                if(!IsPlayerInAnyVehicle(i))
                    return i;
            }
        }
    }
    return -1;
}

strtok(const string[], &index , delimiter = ' ')
{
    new length = strlen(string);
    while ((index < length) && (string[index] <= delimiter))
    {
        index++;
    }

    new offset = index;
    new result[20];
    while ((index < length) && (string[index] > delimiter) && ((index - offset) < (sizeof(result) - 1)))
    {
        result[index - offset] = string[index];
        index++;
    }
    result[index - offset] = EOS;
    return result;
}

public OnPlayerEnterVehicle(playerid, vehicleid, ispassenger)
{
//      printf("OnPlayerEnterVehicle %d %d %d ",playerid , vehicleid , ispassenger);
    return 1;
}

public OnPlayerExitVehicle(playerid, vehicleid)
{
//  printf("OnPlayerExitVehicle %d %d ",playerid ,vehicleid);

    if(isadmin( playerid ))
        if(Make[playerid])
        {
            new File:h = fopen( "races.txt" , io_append);
            new string[256];
            new Float:x,Float:y,Float:z;
            GetPlayerPos(playerid,x,y,z);
            format(string,256,"%f , %f , %f , 10000 , 2 , -1 , -1",x,y,z);
            fwrite(h,string);
            fclose(h);
            fclose(hbot);
            if(timerforcp)
            {
                KillTimer(timerforcp);

                //hbot = File:0;
            }

            StopRecordingPlayerData(playerid);
            Make[playerid] = 0;
            timetaken = 0;
            ignordisk[playerid] =0;
            Message(playerid,"Recoding Stopped.");
        }
    return 1;
}

new timerint[MAX_PLAYERS] = 0;
forward ResetTimerInt( playerid );
public ResetTimerInt( playerid )
{
    timerint[playerid] = 0;
    if(!IsPlayerInAnyVehicle(playerid))
    {
        SpawnCar( playerid );
        if(Race[playerid] != -1)
        {
            PlayerLost(playerid,Race[playerid]);
        }
        if(mpRace[playerid] == 1)
        {
            DisablePlayerRaceCheckpoint(playerid);
            mpRace[playerid] = 0;
            Message(playerid,"You quit the race.");
        }

    }
}

public OnPlayerStateChange(playerid, newstate, oldstate)
{
//  printf("OnPlayerStateChange %d %d %d ",playerid , newstate, oldstate);

    if(oldstate == PLAYER_STATE_DRIVER)
    {
        if(timerint[playerid] <= 5)
        {
            PutPlayerInVehicle( playerid , pCar[playerid] , 0 );
            timerint[playerid]++;
            SetTimerEx("ResetTimerInt",1000,0,"i",playerid);
        }
        else
        {
            SpawnCar( playerid );
            if(Race[playerid] != -1)
            {
                PlayerLost(playerid,Race[playerid]);
            }
            if(mpRace[playerid] == 1)
            {
                DisablePlayerRaceCheckpoint(playerid);
                mpRace[playerid] = 0;
                Message(playerid,"You quit the race.");
            }
        }
    }
    return 1;
}

public OnPlayerEnterCheckpoint(playerid)
{
//  printf("OnPlayerEnterCheckpoint %d " , playerid );
    return 1;
}

public OnPlayerLeaveCheckpoint(playerid)
{
    return 1;
}

stock NextCP( playerid )
{
    DisablePlayerCheckpoint( playerid );
    if(Race[playerid] != -1)
    {
        new string[128];
        format(string,128,"checkpoints/%s.cp",Checkpoints[GetCheckpointId(DidUask[playerid])][ename]);
        printf("%s",string);
        if(fexist(string))
        {
            new File:h = fopen(string,io_read);
            fseek(h,0);
            new c = ++CPid[playerid];
            new l = -1;
            new pstring[128];
            do
            {
                new eof = fread(h,string);
                l++;
                if(eof == 0)
                    l = 9999;
            }
            while(l < c);
            fread(h,pstring);
            fclose(h);
            if(l != 9999)
            {
                new str[128];
                new indx = 0;
                new Float:x,Float:y,Float:z;
                new Float:px,Float:py,Float:pz;
                str = strtok( string , indx , ',' );
                x = floatstr(str);
                str = strtok( string , indx , ',' );
                y = floatstr(str);
                str= strtok( string , indx , ',' );
                z = floatstr( str );
                indx = 0;
                str = strtok( pstring , indx , ',' );
                px = floatstr(str);
                str = strtok( pstring , indx , ',' );
                py = floatstr(str);
                str= strtok( pstring , indx , ',' );
                pz = floatstr( str );

                if(px == 0.0)
                {
                    str = strtok( pstring , indx , ',' );
                    py = floatstr(str);
                    str= strtok( pstring , indx , ',' );
                    pz = floatstr( str );
                    c = Checkpoints[Race[playerid]][eid];
                    px = Checkpoints[c][ex2];
                    py = Checkpoints[c][ey2];
                    pz = Checkpoints[c][ez2];

                }
                SetPlayerRaceCheckpoint(playerid,0,x,y,z-cpbelow,px,py,pz,10);
            }
            else
            {
                c = Checkpoints[Race[playerid]][eid];
                CPid[playerid] = -1;
                SetPlayerRaceCheckpoint( playerid , 2 , Checkpoints[c][ex2],Checkpoints[c][ey2],Checkpoints[c][ez2]-cpbelow,0,0,0,5);
            }
        }
    }
}


public OnPlayerEnterRaceCheckpoint(playerid)
{
//  printf("OnPlayerEnterRaceCheckpoint %d",playerid);
    PlayerPlaySound( playerid , CHECKPOINT_ENTER_SOUND , 0 , 0, 0 );
    if(mpRace[playerid] == 1)
    {
        if(MPCounter != max_counts)
        {
            return 1;
        }
        if(CPid[playerid] != 999)
            nextMPcp(playerid);
        else
        {

            // finish
            Finishmp++;
//          MultiplayerRaceManagement();

            switch(Finishmp)
            {
                case 1:
                {
                    GameTextForPlayer(playerid,"1st!",4000,4);
                    GivePlayerMoney(playerid,Prizemp[0]);
                    new string[256];
                    new name[23];
                    GetPlayerName(playerid,name,23);
                    format(string,256,"%s finished 1st.",name);
                    for(new i  = 0; i< MAX_PLAYERS;i++)
                        if(mpRace[i] == 1)
                            Message(i,string);
                    format(string,256,"- Won a multiplayer race for $%d. [ Balance: $%d ]",Prizemp[0],GetPlayerMoney(playerid));
                    writeracelog( playerid , string );

                    new str[5];
                    new v = strval(pGet(playerid,10));
                    valstr(str,v+1);
                    pSet(playerid,10,str);
                    PlayerPlaySound(playerid,WON_RACE_SOUND,0,0,0);
                }
                case 2:
                {
                    new temp = 0;

                    for(new i = 0;i < MAX_PLAYERS;i++)
                    {
                        if(mpRace[i] == 1)
                            temp++;
                    }
                    if(temp >= 5)
                    {
                        GameTextForPlayer(playerid,"2nd!",4000,4);
                        GivePlayerMoney(playerid,Prizemp[1]);
                        new string[256];
                        new name[23];
                        GetPlayerName(playerid,name,23);
                        format(string,256,"%s finished 2nd.",name);
                        for(new i  = 0; i< MAX_PLAYERS;i++)
                            if(mpRace[i] == 1)
                                Message(i,string);
                        format(string,256,"- Won a multiplayer race for $%d. [ Balance: $%d ]",Prizemp[1],GetPlayerMoney(playerid));
                        writeracelog( playerid , string );
                    }
                }
                case 3:
                {
                    new temp = 0;
                    for(new i = 0;i < MAX_PLAYERS;i++)
                    {
                        if(mpRace[i] == 1)
                            temp++;
                    }
                    if(temp >= 7)
                    {
                        GameTextForPlayer(playerid,"3rd!",4000,4);
                        GivePlayerMoney(playerid,Prizemp[2]);
                        new string[256];
                        new name[23];
                        GetPlayerName(playerid,name,23);
                        format(string,256,"%s finished 3rd.",name);
                        for(new i  = 0; i< MAX_PLAYERS;i++)
                            if(mpRace[i] == 1)
                                Message(i,string);
                        format(string,256,"- Won a multiplayer race for $%d. [ Balance: $%d ]",Prizemp[2],GetPlayerMoney(playerid));
                        writeracelog( playerid , string );
                    }
                }
                default:
                {
                    new string[25];
                    format(string,25,"%dth!",Finishmp);
                    new name[23];
                    GetPlayerName(playerid,name,23);
                    format(string,256,"%s finished dth.",name,Finishmp);
                    for(new i  = 0; i< MAX_PLAYERS;i++)
                        if(mpRace[i] == 1)
                            Message(i,string);
                    GameTextForPlayer(playerid,string,4000,4);
                }
            }
            mpRace[playerid] = 0;
            new temp = 0;
            for(new i = 0;i < MAX_PLAYERS;i++)
            {
                if(mpRace[i] == 1)
                    temp++;
            }
            if(temp < 1)
            {
                mp = -1;
                MultiplayerRaceManagement();
            }

            CPid[playerid] = -1;
            DisablePlayerRaceCheckpoint(playerid);
        }
        return 1;
    }
    if(IsPlayerNPC(playerid))
    {
        if(playerid < max_checkpoints)
        {
            new i;
            for(i = 0;i < MAX_PLAYERS;i++)
            {
                if(IsPlayerConnected(i))
                {
                    if(Race[i] == playerid)
                    {
                        if(!IsPlayerNPC(i))
                        {

                            DisablePlayerRaceCheckpoint( playerid );
                            DisablePlayerRaceCheckpoint( i );
                            new string[30],name[23];
                            GetPlayerName(playerid,name,23);
                            PlayerLost( i , GetCheckpoint(name));
                            format(string,30,"finish %s",name);
                            SendClientMessage(playerid,0,string);
                            break;
                        }
                    }
                }
            }
        }
    }
    else
    {
        if(CPid[playerid] == -1)
        {
            DisablePlayerRaceCheckpoint( playerid );
            DisablePlayerRaceCheckpoint( Race[playerid] );
            new string[30],name[23];
            GetPlayerName(Race[playerid],name,23);
            format(string,30,"finish %s",name);
            SendClientMessage(Race[playerid],0,string);
            PlayerWon( playerid , GetCheckpoint(name));
            PlayerPlaySound(playerid, WON_RACE_SOUND,0,0,0);
        }
        else
        {
            NextCP( playerid );
        }

    }
    return 1;
}

stock PlayerLost( playerid , with )
{
    printf("playerlost");
    with = GetCheckpointId(with);
    new amount = Checkpoints[with][emoney]/Checkpoints[with][eratio];
    if(GetPlayerMoney(playerid) > amount)
    {
        GivePlayerMoney( playerid , -amount);
        new string[256];
        format(string,256,"- Lost a race with %s for $%d. [ Balance: $%d ]",Checkpoints[with][ename],amount,GetPlayerMoney(playerid));
        writeracelog( playerid , string );
    }
    else
    {
        GivePlayerMoney(playerid,-GetPlayerMoney(playerid));
        new string[256];
        format(string,256,"- Lost a race with %s for $%d. [ Balance: $%d ]",Checkpoints[with][ename],GetPlayerMoney(playerid),GetPlayerMoney(playerid));
        writeracelog( playerid , string );
    }
    new name[23];
    GetPlayerName(Race[playerid],name,23);
    new string[128];
    format(string,30,"finish %s",name);
    SendClientMessage(with,0,string);
    DidUask[playerid] = -1;
    format(string,128,"You lost $%d to %s.",amount,name);
    ShowDialog( playerid , dLost, 0 ,"You lost the race !",string,"Ok","Cancel");
    Race[with] = -1;
    Race[playerid] = -1;
    CPid[playerid] = -1;
    PlayerPlaySound(playerid,LOST_RACE_SOUND,0,0,0);
    DisablePlayerRaceCheckpoint( playerid );
}

stock PlayerWon( playerid , with )
{
    GivePlayerMoney(playerid,Checkpoints[with][emoney]);
    new string[256];
    format(string,256,"+ Won a race with %s for $%d. [ Balance: $%d ]",Checkpoints[with][ename],Checkpoints[with][emoney],GetPlayerMoney(playerid));
    writeracelog( playerid , string );
    new name[23];
    GetPlayerName(Race[playerid],name,23);
    format(string,128,"You won $%d from %s.",Checkpoints[with][emoney],name);
    ShowDialog( playerid , dWon, 0 ,"You won the race !",string,"Ok","Cancel");
    DidUask[playerid] = -1;
    Race[playerid] = -1;
    Race[with] = -1;
    bSet( playerid , with , 1 );
    PlayerPlaySound(playerid,WON_RACE_SOUND+1,0,0,0);
}

public OnPlayerLeaveRaceCheckpoint(playerid)
{
    return 1;
}

public OnRconCommand(cmd[])
{
    return 1;
}

public OnPlayerRequestSpawn(playerid)
{
    return 1;
}

public OnObjectMoved(objectid)
{
    return 1;
}

public OnPlayerObjectMoved(playerid, objectid)
{
    return 1;
}
new Blind[MAX_PLAYERS];
new UnBlind[MAX_PLAYERS];

forward BlindPlayer(playerid);
public BlindPlayer(playerid)
{
    SetPlayerWeather(playerid,499);
    SetTimerEx("UnBlindPlayer",500,0,"i",playerid);
    UnBlind[playerid]++;
    if(UnBlind[playerid] == 10)
    {
        KillTimer(Blind[playerid]);
        UnBlind[playerid]= 0;
    }
}
forward UnDrunk(playerid,i);
public UnDrunk(playerid,i)
{
    SetPlayerDrunkLevel(playerid,0);
}

forward UnBlindPlayer(playerid,i);
public UnBlindPlayer(playerid,i)
{
    SetPlayerWeather(playerid,default_weather);
}
public OnPlayerPickUpPickup(playerid, pickupid)
{
    if(DiskP[playerid] != -1) // disk
    {
        if(!IsPlayerNPC(playerid) && GetPlayerWantedLevel(playerid)!=6)
        switch(DiskT[playerid])
        {
            case skid:
            {
                new v = GetPlayerVehicleID(playerid);
                new Float:x,Float:y,Float:z,Float:a;
                GetVehiclePos( v , x,y,z);
                GetVehicleZAngle( v, a);
                new Float:x1,Float:y1;
                if(random(1)==0)
                    a = a + 90;
                else
                    a = a -90;

                x1 = getXfromDistance( x , 1000 , a );
                y1 = getYfromDistance( y , 1000 , a );
                SetVehicleVelocity(v,(x-x1)/(2000),(y1-y)/(2000),0);

                GameTextForPlayer(playerid,"+ skid",2000,1);
                SetPlayerChatBubble(playerid,"skid!",GetPlayerColor(playerid),10,10*1000);
            }
            case jump:
            {
                new Float:x,Float:y,Float:z;
                new v = GetPlayerVehicleID(playerid);
                GetVehicleVelocity(v,x,y,z);
                SetVehicleVelocity(v,x*1.5,y*1.5,z+0.3);
                GameTextForPlayer(playerid,"+ jump",2000,1);
                SetPlayerChatBubble(playerid,"jump!",GetPlayerColor(playerid),10,10*1000);
            }
            case snail:
            {
                new Float:x,Float:y,Float:z;
                new v = GetPlayerVehicleID(playerid);
                GetVehicleVelocity(v,x,y,z);
                SetVehicleVelocity(v,0,0,0);
                GameTextForPlayer(playerid,"+ snail",2000,1);
                SetPlayerChatBubble(playerid,"snail!",GetPlayerColor(playerid),10,10*1000);
            }
            case blind:
            {
                KillTimer(Blind[playerid]);
                Blind[playerid] = SetTimerEx("BlindPlayer",1000,1,"i",playerid);
                GameTextForPlayer(playerid,"+ blind",2000,1);
                SetPlayerChatBubble(playerid,"blind!",GetPlayerColor(playerid),10,10*1000);
            }
            case drunk:
            {
                SetPlayerDrunkLevel(playerid,500000);
                SetTimerEx("UnDrunk",30*1000,0,"i",playerid);
                GameTextForPlayer(playerid,"+ drunk",2000,1);
                SetPlayerChatBubble(playerid,"drunk!",GetPlayerColor(playerid),10,10*1000);
            }
            case rain:
            {
                SetPlayerWeather(playerid,8);
                SetTimerEx("UnBlindPlayer",30*1000,0,"i",playerid);
                GameTextForPlayer(playerid,"+ rain",2000,1);
                SetPlayerChatBubble(playerid,"rain!",GetPlayerColor(playerid),10,10*1000);
            }
            case storm:
            {
                SetPlayerWeather(playerid,19);
                SetTimerEx("UnBlindPlayer",30*1000,0,"i",playerid);
                GameTextForPlayer(playerid,"+ storm",2000,1);
                SetPlayerChatBubble(playerid,"storm!",GetPlayerColor(playerid),10,10*1000);
            }
            case fog:
            {
                SetPlayerWeather(playerid,9);
                SetTimerEx("UnBlindPlayer",30*1000,0,"i",playerid);
                GameTextForPlayer(playerid,"+ fog",2000,1);
                SetPlayerChatBubble(playerid,"fog!",GetPlayerColor(playerid),10,10*1000);
            }
            case blast:
            {
                new Float:x,Float:y,Float:z;
                new v = GetPlayerVehicleID(playerid);
                GetVehiclePos(v,x,y,z);
                CreateExplosion(x,y,z,3,20);
                GameTextForPlayer(playerid,"+ blast",2000,1);
                SetPlayerChatBubble(playerid,"blast!",GetPlayerColor(playerid),10,10*1000);
            }
            case reverse:
            {
                new v = GetPlayerVehicleID(playerid);
                new Float:z;
                new Float:x,Float:y;
                GetVehicleVelocity(v,x,y,z);
                SetVehicleVelocity(v,-x,-y,z);
                GetVehicleZAngle(v,z);
                SetVehicleZAngle(v,z+180);
                GameTextForPlayer(playerid,"+ reverse",2000,1);
                SetPlayerChatBubble(playerid,"reverse!",GetPlayerColor(playerid),10,10*1000);
            }
            case bounce:
            {
                new v = GetPlayerVehicleID(playerid);
                new Float:z;
                new Float:x,Float:y;
                GetVehicleVelocity(v,x,y,z);
                SetVehicleVelocity(v,-x,-y,z);
                GameTextForPlayer(playerid,"+ bounce",2000,1);
                SetPlayerChatBubble(playerid,"bounce!",GetPlayerColor(playerid),10,10*1000);
            }
        }

        DeleteDisk(playerid);
        PlayerPlaySound(playerid,DISK_PICK_SOUND,0,0,0);
    }
    else
    {

    }
    return 1;
}


forward RemoveComponent( playerid , componentid);
public RemoveComponent( playerid , componentid)
{
    new v = GetPlayerVehicleID(playerid);
    RemoveVehicleComponent( v,componentid);
    if(componentid == 1008)
    {
        GivePlayerMoney(playerid,500);
        AddVehicleComponent(v , 1008 );
    }
    if(componentid == 1009)
    {
        GivePlayerMoney(playerid,200);
        AddVehicleComponent(v , 1008 );
    }
    if(componentid == 1010)
    {
        AddVehicleComponent(v , 1008 );
        GivePlayerMoney(playerid,1000);
    }
}
public OnVehicleMod(playerid, vehicleid, componentid)
{
//  printf("OnVehicleMod %d %d ", vehicleid,componentid);
    new slot = GetVehicleComponentType(componentid)+1;
    if((componentid == 1010 ) || (componentid == 1009 ) || (componentid == 1008))
        return SetTimerEx("RemoveComponent",2000,0,"ii",playerid,componentid);

    new str[30];
    valstr(str,componentid);
    cSet( playerid , slot , str );
    return 1;
}

public OnVehiclePaintjob(playerid, vehicleid, paintjobid)
{
//  printf("OnVehiclePaintJob %d %d %d",playerid, vehicleid,paintjobid);
    new str[30];
    valstr(str,paintjobid+1);
    cSet(playerid,15,str);
//  printf("%s",str);
    SetPlayerColor(playerid,COLOR_WHITE);
    return 1;
}

public OnVehicleRespray(playerid, vehicleid, color1, color2)
{
//  printf("OnVehicleRespray %d %d %d %d ", playerid,vehicleid,color1,color2);
    new str[30];
    valstr(str,color1);
    pSet( playerid , 5 , str );
    valstr(str,color2);
    pSet( playerid , 6 , str );
    SetPlayerColor(playerid,GetPlayerColorFromCarColor( color1 ));
    return 1;
}

public OnPlayerSelectedMenuRow(playerid, row)
{
    return 1;
}

public OnPlayerExitedMenu(playerid)
{
    return 1;
}

public OnPlayerInteriorChange(playerid, newinteriorid, oldinteriorid)
{
    return 1;
}
new twiceU[MAX_PLAYERS];
forward TwiceU(playerid);
public TwiceU(playerid)
{
    twiceU[playerid] = 0;
}

new mpTimer;



SetRace( playerid )
{
    new Float:rot;

    new v = GetPlayerVehicleID(playerid);
    GetVehicleZAngle(Checkpoints[mp][ev],rot);
    SetVehiclePos(v,Checkpoints[mp][ex1],Checkpoints[mp][ey1],Checkpoints[mp][ez1]);
    SetPlayerRaceCheckpoint(playerid,0, Checkpoints[mp][ex1],Checkpoints[mp][ey1],Checkpoints[mp][ez1],Checkpoints[mp][ex1],Checkpoints[mp][ey1],Checkpoints[mp][ez1]-10000,25);
    SetVehicleZAngle(v,rot);
    SetVehicleVelocity( v , 0,0,0.3);
    mpRace[playerid] = 1;
    new totalplayers = 0;
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(mpRace[i] == 1)
        {
            totalplayers++;
        }
    }

    if(totalplayers == min_players)
    {
        mpTimer = SetTimerEx("CountMP",2000,1,"");
    }

    if(totalplayers >= min_players)
    {
        MPCounter = 0;
    }
    else
    {
        Message(playerid,"Waiting for more players...");
    }
}

forward CountMP();
public CountMP()
{
    MPCounter++;

    if(MPCounter == max_counts)
    {
        KillTimer(mpTimer);
        StartMPRace();
        for(new i = 0;i < MAX_PLAYERS;i++)
        {
            if(mpRace[i] == 1)
            {
                GameTextForPlayer(i,"GO!",1000,5);
                //SetTimer("MultiplayerRaceManagement",10*60*1000,0);
                PlayerPlaySound( i , GO_SOUND , 0 , 0, 0 );
            }
        }
    }
    else
    {
        new str[25];
        valstr(str,max_counts-MPCounter);
        for(new i = 0;i < MAX_PLAYERS;i++)
        {
            if(mpRace[i] == 1)
            {
                GameTextForPlayer(i,str,1000,5);
                PlayerPlaySound( i , COUNTDOWN_SOUND , 0 , 0, 0 );
            }
        }
    }
}

StartMPRace( )
{
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(mpRace[i] == 1)
        {
            nextMPcp( i );
            CPid[i] = -1; //check
        }
    }
}

nextMPcp( playerid )
{
    if(mpRace[playerid] != -1)
    {
        new string[128];
        format(string,128,"checkpoints/%s.cp",Checkpoints[mp][ename]);

        if(fexist(string))
        {
            new File:h = fopen(string,io_read);
            fseek(h,0);
            new c = ++CPid[playerid];
            new l = -1;
            new pstring[128];
            do
            {
                fread(h,string);
                l++;

            }
            while(l < c);
            new eof = fread(h,pstring);
            if(eof == 0)
                l = 9999;
            fclose(h);
            if(l != 9999)
            {
                new str[128];
                new indx = 0;
                new Float:x,Float:y,Float:z;
                new Float:px,Float:py,Float:pz;
                str = strtok( string , indx , ',' );
                x = floatstr(str);
                str = strtok( string , indx , ',' );
                y = floatstr(str);
                str= strtok( string , indx , ',' );
                z = floatstr( str );
                indx = 0;
                str = strtok( pstring , indx , ',' );
                px = floatstr(str);
                str = strtok( pstring , indx , ',' );
                py = floatstr(str);
                str= strtok( pstring , indx , ',' );
                pz = floatstr( str );

                if(px == 0.0)
                {
                    str = strtok( pstring , indx , ',' );
                    py = floatstr(str);
                    str= strtok( pstring , indx , ',' );
                    pz = floatstr( str );
                    c = Checkpoints[Race[playerid]][eid];
                    px = Checkpoints[c][ex2];
                    py = Checkpoints[c][ey2];
                    pz = Checkpoints[c][ez2];

                }
                SetPlayerRaceCheckpoint(playerid,0,x,y,z-cpbelow,px,py,pz,10);
            }
            else
            {
                c = mp;
                CPid[playerid] = 999;
                SetPlayerRaceCheckpoint( playerid , 2 , Checkpoints[c][ex2],Checkpoints[c][ey2],Checkpoints[c][ez2]-cpbelow,0,0,0,5);
            }
        }
    }
}

forward UpdateNitrox( playerid );
public UpdateNitrox( playerid )
{


    if((GetNitrox( playerid )>0) && (GetKeys(playerid) == 12))
    {
        SetNitrox( playerid , GetNitrox( playerid ) - 1);
        SetTimerEx("UpdateNitrox",100,0,"i",playerid);
//      printf("his key %d and now ?",GetKeys(playerid));
    }
    else
    {
        RemoveVehicleComponent( GetPlayerVehicleID(playerid ) , 1008);
    }
}

public OnPlayerKeyStateChange(playerid, newkeys, oldkeys)
{
    pKey[playerid] = newkeys;
//  printf("OnPlayerKeyStateChange %d %d %d", playerid , newkeys , oldkeys );
    if(newkeys == 12) // NITROX
    {
        if(GetNitrox(playerid)>0)
        {
            SetNitrox(playerid,GetNitrox(playerid)-1);
            AddVehicleComponent(GetPlayerVehicleID(playerid),1008);
            SetTimerEx("UpdateNitrox",100,0,"i",playerid);
        }
    }
    if(oldkeys == 4)
    {
        RemoveVehicleComponent(GetPlayerVehicleID(playerid),1008);
        AddVehicleComponent(GetPlayerVehicleID(playerid),1008);
    }
    if(oldkeys == 16)
    {
        if(GetPlayerVirtualWorld(playerid)>1)
            stopspectate(playerid);
        if(Recording[playerid] == 1)
        {
            if(GetPlayerVirtualWorld(playerid) == 0)
                stoprecord(playerid);
        }
    }

    if(oldkeys == 512)
    {
        if(GetPlayerVirtualWorld(playerid)==0)
            ShowDialog( playerid , dGoto , 2 , "GOTO" , "Change Spawn\nCar Shop\nMultiplayer Race\nRace Log\nAdmins Online\nChange Chat Channel\nHelp" , "Ok" , "Cancel" );
    }
    if(oldkeys == 2)
    {

        if(Race[playerid] != -1)
        {
            PlayerLost( playerid , Race[playerid] );
        }

        else if(mpRace[playerid] == 1)
        {
            mpRace[playerid] = 0;
            DisablePlayerRaceCheckpoint( playerid );
            Message(playerid,"You left the race.");

            if(MPCounter == max_counts)
            {
                // between a race
                new totalplayers = 0;
                for(new i = 0;i < MAX_PLAYERS;i++)
                {
                    if(mpRace[i] == 1)
                    {
                        totalplayers++;
                    }
                }
                if(totalplayers == 0)
                {
                    MultiplayerRaceManagement();
                }
            }
            else if(MPCounter > 0)
            {
                // at counter
                new totalplayers = 0;
                for(new i = 0;i < MAX_PLAYERS;i++)
                {
                    if(mpRace[i] == 1)
                    {
                        totalplayers++;
                    }
                }

                if(totalplayers < min_players)
                {
                    KillTimer(mpTimer);
                }
                MPCounter = 0;
            }
        }
    }
/*
    if((Finishmp == 0) && (Race[playerid] == -1))
    {
        if((oldkeys == 1) && (MPCounter == 0))
        {
            if(mpRace[playerid] == 0)
            {
                new str[5];
                new v = strval(pGet(playerid,9));
                valstr(str,v+1);
                pSet(playerid,9,str);
                SetRace( playerid );
            }
        }

    }
*/
    if(DidUask[playerid] != -1)
    if(oldkeys == 2)
    {
        new bot = DidUask[playerid];
        if(GetDistanceBetweenPlayers(playerid,bot) <= 15)
        {
            new string[512];
            //printf("hm");

            GetPlayerName(bot,string,23);
//          printf("hm");
            new c = GetCheckpoint(string);
            new Float:rot;
            printf("fuck %d %s",c,string);
            GetVehicleZAngle(GetPlayerVehicleID(bot),rot);
            new v = GetPlayerVehicleID(playerid);
            SetVehicleZAngle(v,rot);
            SetVehicleVelocity(v,0,0,0);
            //printf("c %d",c);
            new Float:d = GetDistance(Checkpoints[c][ex1],Checkpoints[c][ey1],Checkpoints[c][ez1],Checkpoints[c][ex2],Checkpoints[c][ey2],Checkpoints[c][ez2]);

            //printf("hm");
            format(string,512,"Description: Bot races are simple, the person who reaches the \
            red marker first wins. The price the challenger gets and the challenge acceptor gets\
            can vary in these types of races.\n\n\n\
            Name:%s\nDistance:%f\nYou win:$%d\nI win:$%d\n\n",Checkpoints[c][ename],d,Checkpoints[c][emoney],Checkpoints[c][emoney]/Checkpoints[c][eratio]);
    //      printf("hm");
            ShowDialog(playerid,dRace,0,"Bot Race !",string,"Accept","Reject");
    //      printf("hm");
        }
    }

    if(newkeys == 8)
    {
        if(twiceU[playerid] == 1)
        {
            if(GetPlayerWantedLevel(playerid) > 0 )
            {
                new Float:a;
                SetPlayerWantedLevel(playerid,GetPlayerWantedLevel(playerid)-1);
                new Float:x,Float:y,Float:z;
                new v = GetPlayerVehicleID(playerid);
                GetVehiclePos( v , x,y,z);
                GetVehicleZAngle( v, a);
                new Float:x1,Float:y1;
                x1 = getXfromDistance( x , 1000 , a );
                y1 = getYfromDistance( y , 1000 , a );
                new Float:x2,Float:y2,Float:z2;
                GetVehicleVelocity(v,x2,y2,z2);
                SetVehicleVelocity(v,x2+(x-x1)/(1000),y2+(y1-y)/(1000),0);
                GetXYbehindPlayer( v, 0.5, x , y  );
                CreateExplosion( x  , y , z , 4 , 10 );
                //SetPlayerArmour(playerid, 100);
                PlayerPlaySound(playerid,DISK_SOUND,0,0,0);
            }
        }
        else
        {
            twiceU[playerid] = 1;
            SetTimerEx("TwiceU",200,0,"i",playerid);
        }
    }
    // down key is 32
    if(GetPlayerVirtualWorld( playerid ) > 1000 )
    {
        if(newkeys == KEY_LOOK_LEFT)
        {
            new id = GetPlayerVirtualWorld( playerid ) - 1000;
            if(id == 1)
                id = sizeof(cars);
            ShowCar( playerid ,id - 1 );
        }
        else if(newkeys == KEY_LOOK_RIGHT)
        {
            new id = GetPlayerVirtualWorld( playerid ) - 1000;
            if(id == sizeof(cars)-1)
                id = 0;
            ShowCar( playerid ,id + 1 );
        }
        else if(newkeys == KEY_SECONDARY_ATTACK)
        {
            if(pCar[playerid])
                ShowDialog( playerid , dExit , 0 ,"Car Shop" , "Are you sure you to leave ?", "Ok","Cancel");
        }
        else if(newkeys == KEY_SPRINT)
        {
            new level = GetPlayerLevel(playerid);
            new id = GetPlayerVirtualWorld( playerid ) - 1000;
            new pcar = GetModelCost( strval( pGet( playerid , 4 ) ) );
            new got = GetPlayerMoney( playerid ) + pcar;
            if(level < cars[id][elevel])
            {
                ShowDialog( playerid , dCant , 0 , "Car Shop" , "The car is locked.", "Ok" , "Cancel" );
            }
            else
            if(cars[id][ecost] < got)
            {
                new cash;
                if(pcar > cars[id][ecost])
                {
                    cash = 0;
                }
                else
                {
                    cash = cars[id][ecost] - pcar;
                }
                new string[256];
                format(string,256,"Are you sure you want to exchange this car for $%d.",cash);
                ShowDialog( playerid , dPurchase , 0 , "Car Shop" , string , "Ok" , "Cancel" );
                Purchase[playerid] = cash;
            }
            else
            {
                new string[256];
                new cash = cars[id][ecost] - pcar - GetPlayerMoney( playerid );
                format(string,256,"You will need more $%d to exchange this car.",cash);
                ShowDialog( playerid , dCant , 0 , "Car Shop" , string , "Ok" , "Cancel" );
            }
        }
    }
    return 1;
}
stock GetPlayerLevel(playerid)
{
    new win = strval(pGet( playerid, 3));
    new level = 1;
    if(win >= 20)
        level = 4;
    else if(win >= 10)
        level = 3;
    else if(win >= 5)
        level = 2;
    return level;
}

public OnRconLoginAttempt(ip[], password[], success)
{
    return 1;
}

new Money[MAX_PLAYERS];
public OnPlayerUpdate(playerid)
{
    new str[64];
    new Float:v,Float:x,Float:y,Float:z;
    GetVehicleVelocity(GetPlayerVehicleID(playerid),x,y,z);
    if(x < 0) x = x + -x + -x;
    if(y < 0) y = y + -y + -y;
    if(z < 0) z = z + -z + -z;
    v = ((x * 1) + (y * 1) + (z * 1))*70;
    format(str,20,"\n\n%.2fkmph",v);
    Update3DTextLabelText(DDD[playerid],GetPlayerColor(playerid),str);
    SetSpeed(playerid,floatround(v));

//  SetPlayerHealth( playerid , 1000 ); // manage health


    new name[23];
    GetPlayerName(playerid,name,23);
    format(str,64,"\n\n\n\n\n\n\n\nName: %s\nCash: $%d",name,GetPlayerMoney(playerid));
    Update3DTextLabelText(DDD2[playerid],GetPlayerColor(playerid),str);

    if(IsPlayerNPC(playerid))
     return 1;

    new money = Money[playerid] - GetPlayerMoney(playerid);
    Money[playerid] = GetPlayerMoney(playerid);

    GetVehicleVelocity(GetPlayerVehicleID(playerid),x,y,z);

    new speed = floatround(v);
    if((speed > 120) || (money > 1000))
    {
        new pickup[20];
        GetPlayerName(playerid,name,23);
        format(str,128,"%s[%d] money: %d speed: %d last-pickup: %s.",name,playerid,money,speed,pickup);
        for(new i = 0;i < MAX_PLAYERS;i++)
        {
            if(IsPlayerConnected(i))
            {
                if(!IsPlayerNPC(i))
                {
                    if(isadmin(i))
                    {
                        if(alerts[i] != 0)
                            SendClientMessage(i,0xFFFFFFAA,str);
                    }
                }
            }
        }
    }
    return 1;
}

public OnPlayerStreamIn(playerid, forplayerid)
{
    return 1;
}

public OnPlayerStreamOut(playerid, forplayerid)
{
    return 1;
}

new StreamedFor[MAX_PLAYERS];

stock GetVehicleDriver(vehicleid)
{
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerConnected(i))
        if(IsPlayerInVehicle(i,vehicleid))
        {
            return i;
        }
    }
    return -1;
}

stock IsVehicleStreamedInForAny(v)
{
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerConnected(i))
        {
            if(IsVehicleStreamedIn(v,i))
                if(GetVehicleDriver(v)!=i)
                {
                    printf("this guy %d",i);
                    return 1;
                }
        }
    }
    return 0;
}
stock GetFreeNPC()
{
    for(new i = 0;i < MAX_PLAYERS; i++)
    {
        if(IsPlayerConnected(i))
        if(IsPlayerNPC(i))
        if(FreeNPC[i] == 1)
        {
            printf("Free Bot: %d",i);
            return i;
        }
    }
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerConnected(i))
        if(IsPlayerNPC(i))
        if(IsPlayerInAnyVehicle(i))
        if(!IsVehicleStreamedInForAny(GetPlayerVehicleID(i)))
        {
            RemovePlayerFromVehicle(i);
            SetPlayerVirtualWorld(i,3434);
            FreeNPC[i] = 1;
            return i;
        }
        else
        {
            RemovePlayerFromVehicle(i);
            SetPlayerVirtualWorld(i,3434);
            FreeNPC[i]= 1;
            return i;
        }
    }
    printf("Free Npc not therE?");
    return -1;
}



public OnVehicleStreamIn(vehicleid, forplayerid)
{
    if(vehicleid< sizeof(cars))
    {
        SetVehicleVirtualWorld( vehicleid  , 1000 + vehicleid );
        return 1;
    }
/*  if(IsPlayerNPC(forplayerid))
        return 1;
    if(GetPlayerVirtualWorld(forplayerid)!=0)
        return 1;
    if(Race[forplayerid] != -1)
        return 1;
    if(mpRace[forplayerid] != 0)
        return 1;
    for(new i = 0;i < max_checkpoints;i++)
    {
        if(Checkpoints[i][ev] == vehicleid)
        {
            if(GetVehicleDriver(vehicleid) == -1)
            {
                new n = GetFreeNPC();
                if(n != -1)
                {
                    FreeNPC[n] = 0;
                    SetPlayerVirtualWorld(n,0);
                    PutPlayerInVehicle(n,vehicleid,0);
                    new string[30];
                    SetPlayerName(n,Checkpoints[i][ename]);
                    format(string,30,"finish %s",Checkpoints[i][ename]);
                    printf(string);
                    SendClientMessage(n,0,string);
                    StreamedFor[forplayerid] = n;
                    Checkpoints[i][eid] = n;
                    return 1;
                }
            }
        }
    }
*/
/*

    for(new i = 0;i < max_checkpoints;i++)
    {
        if(Checkpoints[i][ev] == vehicleid)
        {
            if(!IsPlayerInAnyVehicle( i ))
            {
                SetPlayerVirtualWorld(Checkpoints[i][eid],0);
                PutPlayerInVehicle(Checkpoints[i][eid],vehicleid,0);
                new string[30];
                format(string,30,"finish %s",Checkpoints[GetCheckpointId(i)][ename]);
                SendClientMessage(Checkpoints[i][eid],0,string);
            }
        }
    }
*/
/*  new load = 1;
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerInVehicle(i,vehicleid))
            load = 0;
    }
    if(load == 1)
    for(new i = 0;i < max_checkpoints;i++)
    {
        if(Checkpoints[i][ev] == vehicleid)
        {
            for(new j = 0;j <MAX_PLAYERS;j++)
            {
                if(IsPlayerNPC(j))
                {
                    if(!IsPlayerInAnyVehicle(j))
                    {
                        PutPlayerInVehicle(j,vehicleid,0);
                        new string[30],name[23];
                        GetPlayerName(j,name,23);
                        format(string,30,"finish %s",name);
                        Message(j,0,string);
                        break;
                    }
                }
            }
        }
    }

*/

    return 1;
}

public OnVehicleStreamOut(vehicleid, forplayerid)
{
/*
    if(IsPlayerNPC(forplayerid))
        return 1;
    if(GetPlayerVirtualWorld(forplayerid)!=0)
        return 1;
    if(Race[forplayerid] != -1)
        return 1;
    if(mpRace[forplayerid] != 0)
        return 1;

    if(StreamedFor[forplayerid] != -1)
    {
        for(new i = 0;i < MAX_PLAYERS;i++)
        {
            if(IsPlayerConnected(i))
                if(forplayerid != i)
                    if(StreamedFor[i] == StreamedFor[forplayerid])
                    {
                        StreamedFor[forplayerid] = -1;
                        return 1;
                    }
        }

        if(IsPlayerNPC(GetVehicleDriver(vehicleid)))
        {
            new n = StreamedFor[forplayerid];
            RemovePlayerFromVehicle(n);
            SetPlayerVirtualWorld(n,3434);
            FreeNPC[n] = 1;
            StreamedFor[forplayerid] = -1;
        }

    }
*/
    return 1;
}
forward Countdown(playerid,count);
public Countdown(playerid,count)
{

    new Float:x,Float:y,Float:z;
    GetVehicleVelocity(GetPlayerVehicleID(playerid),x,y,z);
    if((x < 0.1) && (y < 0.1))
    {
        count--;
        if(count == 0)
        {
            PlayerPlaySound( playerid , GO_SOUND , 0 , 0, 0 );
            GameTextForPlayer(playerid,"~g~GO !",1000,5);
            //Dist[playerid] =CreatePlayer3DTextLabel(playerid,"Distance",0xFFFFFFAA,Checkpoints[Race[playerid]][ex2],Checkpoints[Race[playerid]][ey2],Checkpoints[Race[playerid]][ez2],9999.9999 ,0 );
            //UpdateCheckpoints(playerid);
            StartRace( playerid);
            new r = strval(pGet( playerid , 8 ))+1;
            new rs[10];
            valstr(rs,r);
            pSet( playerid , 22 , rs );
        }
        else
        {
            if(count == 3)
            {
                GameTextForPlayer(playerid,"~r~3",1000,5);
                PlayerPlaySound( playerid , COUNTDOWN_SOUND , 0 , 0, 0 );
            }
            if(count == 2)
            {
                GameTextForPlayer(playerid,"~r~2",1000,5);
                NextCP( playerid );
                PlayerPlaySound( playerid , COUNTDOWN_SOUND , 0 , 0, 0 );
            }
            if(count == 1)
            {
                GameTextForPlayer(playerid,"~r~1",1000,5);
                PlayerPlaySound( playerid , COUNTDOWN_SOUND , 0 , 0, 0 );
            }
            SetTimerEx("Countdown", 1000,0,"ii",playerid,count);
        }
    }
    else
    {
        ShowDialog( playerid , dLost, 0 ,"Race !","You left the race","Ok","Cancel");
        DidUask[playerid] = -1;
        Race[Race[playerid]] = -1;
        DisablePlayerRaceCheckpoint(playerid);
        Race[playerid] = -1;
        PlayerPlaySound(playerid,QUIT_RACE_SOUND,0,0,0);
    }
}
new Password[MAX_PLAYERS][30];
public OnDialogResponse(playerid, dialogid, response, listitem, inputtext[])
{
    PlayerPlaySound(playerid,DIALOG_CLICK_SOUND,0,0,0);
    dialogid = CurrentDialog[playerid];
//  printf( "OnDialogResponse %d %d %d %d %s",playerid,dialogid,response,listitem,inputtext);
    if(response == 1)
    {
        if(dialogid == dTeleport)
        {
            for(new i = 0;i < MAX_PLAYERS;i++)
            {
                if(IsPlayerConnected(i))
                {
                    if(!IsPlayerNPC(i))
                    {
                        new name[15];
                        GetPlayerName(i,name,15);
                        if(com(name,inputtext)==0)
                        {
                            if(GetPlayerVirtualWorld(i)==0)
                            {
                                new Float:x,Float:y,Float:z;
                                GetVehiclePos(GetPlayerVehicleID(i),x,y,z);
                                SetVehiclePos(GetPlayerVehicleID(playerid),x,y,z+2);
                            }
                            else
                                Message(playerid,"You can't teleport to there right now.");
                        }
                    }
                }
            }
        }
        else if(dialogid == dColorize)
        {
            switch(listitem)
            {
                case 0: // white
                {
                    ShowDialog( playerid , dWhite , 2 , "Choose a color" , "Milk White" , "Ok" , "Cancel" );
                }
                case 1: // yellow
                {
                    ShowDialog( playerid , dYellow , 2  , "Choose a color" , "Light Yellow\nDark Yellow\nYellow" , "Ok" , "Cancel" );
                }
                case 2: // green
                {
                    ShowDialog( playerid , dGreen , 2  , "Choose a color" , "Light Green\nDark Green\nYellow Green" , "Ok" , "Cancel" );
                }
                case 3: // blue
                {
                    ShowDialog( playerid , dBlue , 2  , "Choose a color" , "Yellow Blue\nSky Blue\nDark Blue\nLight Blue\nGreen Blue" , "Ok" , "Cancel" );
                }
                case 4: // pink
                {
                    ShowDialog( playerid , dPink , 2  , "Choose a color" , "Yellow Pink\nDark Pink" , "Ok" , "Cancel" );
                }
                case 5: // red
                {
                    ShowDialog( playerid , dRed , 2 , "Choose a color"  , "Dark Red\nLight Red\nMaroon\nBrown" , "Ok" , "Cancel" );
                }
                case 6: // black
                {
                    ShowDialog( playerid , dBlack , 2  , "Choose a color" , "Grey\nBlack" , "Ok" , "Cancel" );
                }
            }
        }
        else if(dialogid == dWhite)
        {
            if(listitem == 0)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),1,1);
                pSet(playerid,5,"1");
                pSet(playerid,6,"1");
            }
        }
        else if(dialogid == dYellow)
        {
            if(listitem == 0)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),65,65);
                pSet(playerid,5,"65");
                pSet(playerid,6,"65");
            }
            if(listitem == 1)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),6,6);
                pSet(playerid,5,"6");
                pSet(playerid,6,"6");
            }
            if(listitem == 2)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),128,128);
                pSet(playerid,5,"128");
                pSet(playerid,6,"128");
            }

        }
        else if(dialogid == dGreen)
        {
            if(listitem == 0)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),16,16);
                pSet(playerid,5,"16");
                pSet(playerid,6,"16");
            }
            if(listitem == 1)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),44,44);
                pSet(playerid,5,"44");
                pSet(playerid,6,"44");
            }
            if(listitem == 2)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),86,86);
                pSet(playerid,5,"86");
                pSet(playerid,6,"86");
            }
        }
        else if(dialogid == dBlue)
        {
            if(listitem == 0)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),2,2);
                pSet(playerid,5,"2");
                pSet(playerid,6,"2");
            }
            if(listitem == 1)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),7,7);
                pSet(playerid,5,"7");
                pSet(playerid,6,"7");
            }
            if(listitem == 2)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),79,79);
                pSet(playerid,5,"79");
                pSet(playerid,6,"79");
            }
            if(listitem == 3)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),100,100);
                pSet(playerid,5,"100");
                pSet(playerid,6,"100");
            }
            if(listitem == 4)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),93,93);
                pSet(playerid,5,"93");
                pSet(playerid,6,"93");
            }
        }
        else if(dialogid == dPink)
        {
            if(listitem == 0)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),5,5);
                pSet(playerid,5,"5");
                pSet(playerid,6,"5");
            }
            if(listitem == 1)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),85,85);
                pSet(playerid,5,"85");
                pSet(playerid,6,"85");
            }
        }
        else if(dialogid == dRed)
        {
            if(listitem == 0)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),3,3);
                pSet(playerid,5,"3");
                pSet(playerid,6,"3");
            }
            if(listitem == 1)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),42,42);
                pSet(playerid,5,"42");
                pSet(playerid,6,"42");
            }
            if(listitem == 2)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),74,74);
                pSet(playerid,5,"74");
                pSet(playerid,6,"74");
            }
            if(listitem == 3)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),123,123);
                pSet(playerid,5,"123");
                pSet(playerid,6,"123");
            }
        }
        else if(dialogid == dBlack)
        {
            if(listitem == 0)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),122,122);
                pSet(playerid,5,"122");
                pSet(playerid,6,"122");
            }
            if(listitem == 1)
            {
                ChangeVehicleColor(GetPlayerVehicleID(playerid),0,0);
                pSet(playerid,5,"0");
                pSet(playerid,6,"0");
            }
        }
        if((dialogid >= dWhite) && (dialogid <= dBlack))
        {
            new c1 = strval(pGet(playerid,5));
            SetPlayerColor(playerid,GetPlayerColorFromCarColor( c1 ));
        }
    }

    if(dialogid == dRecord)
    {
        Message(playerid,"Temporarily disabled");
        /*
        if(strlen(inputtext) > 0)
        {
            new string[256];
            format(string,256,"%s\n%s\n%s\n%s\n%s",cGet( playerid , 1 ),cGet( playerid , 2 ),cGet( playerid , 3 ),cGet( playerid , 4 ),cGet( playerid , 5 ));
            format(Rc[ playerid ],30,"%s",inputtext);
            ShowDialog( playerid , dRec , 2 ,"Record", string,"Ok","Cancel");
        }
        else
        {
            ShowDialog( playerid , dRecord , 1 ,"Record", "Enter a name.","Ok","Cancel");
        }
        */
    }
    else if(dialogid == dGoto)
    {
        if(response)
        {
            switch(listitem)
            {
                case 0:
                {
                    if((GetPlayerVirtualWorld(playerid)==0) && (Race[playerid] == -1) && (mpRace[playerid] != 1))
                        SpawnCar( playerid );
                }
                case 1:
                {
                    if((GetPlayerVirtualWorld(playerid)==0) && (Race[playerid] == -1) && (mpRace[playerid] != 1))
                        Shop( playerid );
                }
                case 2:
                {
                    if((Finishmp == 0) && (Race[playerid] == -1))
                    {
                        if((MPCounter == 0))
                        {
                            if(mpRace[playerid] == 0)
                            {
                                new str[5];
                                new v = strval(pGet(playerid,9));
                                valstr(str,v+1);
                                pSet(playerid,9,str);
                                SetRace( playerid );
                            }
                        }
                    }
                }
/*              case 4:
                {
                    if(Recording[playerid] == 0)
                        ShowDialog( playerid , dRecord , 1 , "Record" , "Enter a name.","Ok","Cancel");
                    else
                        Message(playerid,"You are already recording, Press H to stop it.");
                }
                case 5:
                {
                    new string[256];
                    format(string,256,"%s\n%s\n%s\n%s\n%s",cGet( playerid , 1 ),cGet( playerid , 2 ),cGet( playerid , 3 ),cGet( playerid , 4 ),cGet( playerid , 5 ));
                    ShowDialog( playerid , dPlay , 2 ,"Playback", string,"Ok","Cancel");
                }
                case 3:
                {
                    if(IsPlayerInAnyVehicle(playerid))
                    {
                        ShowDialog( playerid , dColorize , 2 , "Colorize" , "White\nYellow\nGreen\nBlue\nPink\nRed\nBlack", "Ok", "Cancel");
                    }
                }
*/              case 3:
                {
                    const lin = 32;
                    new sub[lin],str[40*lin];
                    new name[23];
                    GetPlayerName(playerid,name,23);
                    format(sub,lin,"racelog/%s.log",name);
                    if(fexist(sub))
                    {
                        new File:h = fopen( sub , io_read );
                        for(new i = 0;i < 40;i++)
                        {
                            fread(h,sub);
                            strins(str,sub,strlen(str));
                        }

                        fclose(h);
                    }
                    else
                    {
                        format(str,lin,"<empty>");
                    }
                    ShowDialog( playerid , dCant , 2 ,"Race Log", str , "Ok", "Cancel");
                }
                case 4:
                {
                    new string[1024];
                    new bing =0;
                    for(new i = 0;i < MAX_PLAYERS;i++)
                    {
                        if(IsPlayerConnected(i))
                        {
                            if(!IsPlayerNPC(i))
                            {
                                if(isadmin(i))
                                {
                                    bing = 1;
                                    new name[23];
                                    GetPlayerName(i,name,23);
                                    strins(string,name,strlen(string));
                                    strins(string,"\n",strlen(string));
                                }
                            }
                        }
                    }
                    if(bing == 0)
                        strins(string,"none",0);
                    ShowDialog( playerid , dOk ,  2 , "Admins Online", string , "Ok" , "Cancel" );
                    Message(playerid,"Use @<message> to send admins a message.");
                }
                case 5:
                {
                    ShowDialog( playerid , dChannel , 1 , "Change Chat Channel" , "Enter a channel name:", "Ok" , "Cancel");
                }
                case 6:
                {
                    PlayerPlaySound(playerid,1185,0,0,0);
                    ShowDialog( playerid , dHelp , 2 , "Help" , "Multiplayer Race\nBot Race\nRespawn\nRecord Playback\nStar\nCar Shop\nLevels\nKey Controls\nChat Channels" , "Ok" , "Cancel" );
                }
            }
        }
    }
    else if(dialogid == dChannel)
    {
        if(response)
        {
            if(!strlen(inputtext))
            {
                format(Channel[playerid],128,"Global");
                new string[256];
                format(string,256,"You have changed your chat channel to: Global");
                Message(playerid,string);
                CLS(playerid);
            }
            else if(strlen(inputtext)<10)
            {
                format(Channel[playerid],128,"%s",inputtext);
                new string[256];
                format(string,256,"You have changed your chat channel to: %s",inputtext);
                Message(playerid,string);
                CLS(playerid);
            }
        }
    }
    else if(dialogid == dHelp)
    {
        if(response)
        {
            if(listitem == 0)
            {

                ShowDialog( playerid , dSubHelp , 0 , "Multiplayer Race" , \
"These races start every 15 minutes at different spots. You need not bother about reaching there, \
just by hitting 'CTRL' you will join the race immedietly. The race allots 2nd and 3rd prizes too \
if there are more then 5 and 7 players in the race respectively. Race can be left simply by using 'H' key." \
                 , "Ok" , "Cancel" );
            }
            if(listitem == 1)
            {
                ShowDialog( playerid , dSubHelp , 0 , "Bot Race" , \
"These are races which you play with bots, you can beat them with ease if you got enough skills. \
Bots don't use pickups, by which you can take a lot of advantage. In these races if you lost \
the race you loose money, vice versa. You can leave the race by using 'H' key though it will \
mean that you gave up, i.e you lost the race and the money too."\
                 , "Ok" , "Cancel" );
            }
            if(listitem == 2)
            {
                ShowDialog( playerid , dSubHelp , 0 , "Respawn" , \
"You use the H key when not in a race, to change where your car spawned. There are \
 many different places, where you can get respawned."\
                 , "Ok" , "Cancel" );
            }

            if(listitem == 3)
            {
                ShowDialog( playerid , dSubHelp , 0 , "Record Playback" , \
"You can record yourself for 3 minutes(maximum) using /record command. To stop recoding once you \
started it use /stop command. Recordings will be stoped automatically once it reaches 3 minutes \
though. Later on you can again view the reply using /play command. You can also record while \
on a race. NOTE: This is temperarily out of service."\
                 , "Ok" , "Cancel" );
            }
            if(listitem == 4)
            {
                ShowDialog( playerid , dSubHelp , 0 , "Star" , \
"Star is one of the pickups you find on the roads. A star is the most beneficial pickup. You can \
use a star like a nitrox to your car. To use a star you will need to Double Click your 'W' key. \
And also if you collect all 6 stars, then you will be in a stage where you wont affected by any \
other pickup like blind, bounce, reverse etc."\
                 , "Ok" , "Cancel" );
            }
            if(listitem == 5)
            {
                ShowDialog( playerid , dSubHelp , 0 , "Car Shop" , \
"At anytime in the game, you could reach the car shop using /shop command. There you can exchange \
your old car with any of those cars over there, if you have enough money and level. You shall \
use 'Q' and 'E' keys to scroll the cars and 'SPACEBAR' to select a car. You can leave the shop \
using 'ENTER' key."\
                 , "Ok" , "Cancel" );
            }
            if(listitem == 6)
            {
                ShowDialog( playerid , dSubHelp , 0 , "Levels" , \
"Currently the system supports 4 levels. Everyone who join the server starts with level 1. Later \
when you finish, i.e win 5 bot races, you go to level 2. Win 10 bot races, you go to level 3. \
Win 20 bot races, you reach level 4. Leveling up will unlock the cars at the car shop."\
                 , "Ok" , "Cancel" );
            }

            if(listitem == 7)
            {
                ShowDialog( playerid , dSubHelp , 2 , "Key Controls" , "\
Server Used Names           Game Used Names\n\
Q                   Look Left\n\
E                   Look Right\n\
W                   Accelerate\n\
ALT                 Walk\n\
ENTER                   Secoundary Attak\n\
SPACEBAR                Sprint\n\
2                   Accept Mission\n\
H                   Horn\n"\
                 , "Ok" , "Cancel" );

            }
            if(listitem == 8)
            {
                ShowDialog( playerid , dSubHelp , 0 , "Chat Channels" , \
"You can create your own chat channel and ask your friends to join in that channel, players of \
one channel can not hear what players of other channel are speaking. By default everyones \
chat channel is 'Global'." \
                 , "Ok" , "Cancel" );
            }
        }
        else
        {
            PlayerPlaySound(playerid,1186,0,0,0);
        }
    }

    else if(dialogid == dSubHelp)
    {
        PlayerPlaySound(playerid,1186,0,0,0);
    }
    else if(dialogid == dRec)
    {
        if(response)
        {
            record( playerid , listitem+1 , Rc[playerid ] );
        }
    }
    else if(dialogid == dPlay)
    {
        if(response)
        {
            if(strcmp("Empty",inputtext)!=0)
                play( playerid , inputtext);
        }
    }
    else if(dialogid == dWon)
    {
        new string[30];

        new races = strval(pGet( playerid , 3 ));
        valstr(string,races+1);
        PlayerPlaySound(playerid,LEVEL_UP_SOUND,0,0,0);
        pSet( playerid , 3 , string );
        if(races+1 == 5)
            ShowDialog( playerid , dCant , 0 ,"Level Up !","Congrats !, you are now level 2.", "Ok" , "Cancel" );
        if(races+1 == 10)
            ShowDialog( playerid , dCant , 0 ,"Level Up !","Congrats !, you are now level 3.", "Ok" , "Cancel" );
        if(races+1 == 20)
            ShowDialog( playerid , dCant , 0 ,"Level Up !","Congrats !, you are now level 4.", "Ok" , "Cancel" );
    }

    else if(dialogid == dRace)
    {
        if(response == 1)
        {
            SetTimerEx("Countdown", 1000,0,"ii",playerid,4);
            Race[playerid] = DidUask[playerid];
            Race[Race[playerid]] = playerid;
            new str[5];
            new v = strval(pGet(playerid,8));
            valstr(str,v+1);
            pSet(playerid,8,str);
            SendPlayerMessageToPlayer(playerid,playerid,"yea..");
            Message(playerid,"Press H to quit the race.");
        }
    }
    else if(dialogid == dExit)
    {
        if(response)
        {
            HideTextDraws( playerid );
            StopCameraRot( playerid );
            SetPlayerVirtualWorld( playerid, 0);
            SpawnCar( playerid );
            TogglePlayerControllable( playerid , 1);
        }
    }
    else if(dialogid == dPurchase)
    {
        if(response == 1)
        {
            GivePlayerMoney(playerid,-Purchase[playerid]);
            new string[256];
            format(string,256,"- Purchased a car for $%d. [ Balance: $%d ]",Purchase[playerid],GetPlayerMoney(playerid));
            writeracelog( playerid , string );
            new First = 0;
            if(com("0",pGet(playerid,4))==0)
                First = 1;
            PurchaseCar( playerid );
            if(First == 1)
                Message(playerid,"At any time in the server, press the '2' key for Help.");
            HideTextDraws( playerid );
        }
    }
    else if(dialogid == dLogin)
    {
        if(response == 0)
            Kick( playerid );
        else
        {
            //printf(" %s %s ",pGet( playerid , 1 ) , inputtext );
            new string[256];
            format(string,30,"%s",inputtext);

            if(com(string,pGet(playerid,1),true)==0)
            {
                TogglePlayerControllable(playerid ,1);
                LoadPlayerCar( playerid );
                SpawnCar( playerid );
                // login
                TextDrawShowForPlayer( playerid , WWW );
                SetPlayerScore(playerid,GetPlayerLevel(playerid));
                GivePlayerMoney( playerid , strval( pGet( playerid , 2 ) ) );
                TextDrawShowForPlayer(playerid, VertiDraw[playerid]);

            }
            else
            {
                ShowDialog( playerid , dLogin , 1 , "Authentication Required" , "You have entered a wrong password, Try again", "Login" , "Quit" );
            }
        }
    }
    else if(dialogid == dRegister1)
    {
        if(response == 0)
          Kick( playerid );
        else
        {
            ShowDialog( playerid , dRegister2 , 1 , "Welcome To Ride" , "You will have to register an account in\
            our server in order to continue, Type in a password to register with us." , "Register" , "Back" );
            TextDrawShowForPlayer(playerid, VertiDraw[playerid]);
        }
    }

    else if(dialogid == dRegister2)
    {
        if(response == 0)
            ShowDialog( playerid, dRegister1 , 0 , "Welcome To Ride" , "This server might contain elements which \
            are not suitable for children below 13. By pressing 'continue' you mean that you are above or equal to 13\
            years old." , "Continue" , "Quit");
        else
        {
            if((strlen(inputtext) < 15) && (strlen(inputtext) > 3 ))
            {
                format(Password[playerid], 30 , "%s" ,  inputtext );
                ShowDialog( playerid , dRegister3 , 1 , "Welcome To Ride" , "Confirm your password.", "Confirm" , \
                "Back" );
            }
            else
            {
                ShowDialog( playerid , dRegister2 , 1 , "Welcome To Ride" , "Your password must be greater\
                 than 3 characters and less than 15 characters.", "Register" , "Back" );
            }

        }
    }
    else if(dialogid == dRegister3)
    {
        if(response == 0)
            ShowDialog( playerid , dRegister2 , 1 , "Welcome To Ride" , "You will have to register an account in\
            our server in order to continue, Type in a password to register with us." , "Register" , "Back" );
        else
        {

            if((com(Password[playerid],inputtext)==0) && (strlen(inputtext)))
            {
                ShowDialog( playerid , dRegistered , 0 , "Welcome To Ride" , "Congrats, your account has been \
                successfully created." , "Ok" , "Cancel" );
                pRegister( playerid , inputtext );
                GivePlayerMoney( playerid , 4000 );
                writeracelog(playerid,"+ Career started with $4000. [ Balance: $4000 ]");
            }
            else
            {
                ShowDialog( playerid , dRegister2 , 1 , "Welcome To Ride" , "Your passwords did not match type \
                in your password again." , "Register" , "Back" );
            }
        }
    }
    else if(dialogid == dRegistered)
    {
        Shop( playerid );
    }
    return 1;
}

forward OnPlayerJoin( playerid , registered );
public OnPlayerJoin( playerid , registered )
{
    if(registered)
    {
        ShowDialog( playerid, dLogin , 1 , "Authentication Required" , "Password:" , "Login" , "Quit");
    }
    else
    {
        ShowDialog( playerid, dRegister1 , 0 , "Welcome To Ride" , "This server might contain elements which \
        are not suitable for children below 13. By pressing 'continue' you mean that you are above or equal to 13\
        years old." , "Continue" , "Quit");
    }
}

stock len(string1[])
{
    new c;
    new i = 0;
    do
    {
        c = string1[i];
        //printf("'%d'",c);
        if(c == '\0')
            break;
        if(c == '\r')
            break;
        if(c == '\n')
            break;
        i = i + 1;
    }
    while(i > -1);
    return i;
}

stock com( string1[] , string2[] , b = 1 , l = 1 )
{
    //printf("com '%s' '%s' %d %d ",string1,string2,strlen(string1),strlen(string2));
    new i = len(string1);
    new j = len(string2);
    if(i != j)
        return 1;
    b = l;
    l = b;
    for(i = 0;i < j;i++)
    {
        if(string1[i] != string2[i])
            return 1;
    }
    //printf("equal");
    return 0;
}
forward pRegister( playerid , password[] );
public pRegister( playerid , password[] )
{
    if(!IsPlayerNPC(playerid))
    {
        new name[23],file[30];
        GetPlayerName( playerid , name ,23 );
        format( file , 30 , "players/%s.ini" , name );
        new File:h = fopen( file , io_write );
        format( file , 30 , "%s\r\n" , password );
        fwrite(h , file );
        fwrite(h, "0\r\n");
        fwrite(h , "1\r\n" );
        fwrite(h , "0\r\n" );
        fwrite(h , "0\r\n" );
        fwrite(h , "0\r\n" );
        format( file , 30 , "%d\r\n" , GetPlayerSkin(playerid) );
        fwrite(h , file );// 7
        fwrite(h , "0\r\n" ); // 8
        fwrite(h , "0\r\n" ); // 9
        fwrite(h , "0\r\n" ); // 10
        fclose( h );
        bRegister( playerid );
        cRegister( playerid );
    }
}

stock pGet( playerid , index  )
{
    new key[30];
    if(!IsPlayerNPC(playerid))
    {
        new name[23],file[30];
        GetPlayerName( playerid , name ,23 );
        format( file , 30 , "players/%s.ini" , name );
        new File:h = fopen( file , io_read );
        for(new i = 0;i < index; i++)
        {
            fread( h , key , 30 );
        }
        fclose( h );
    }
    return key;
}

forward pSet( playerid , index , key[] );
public pSet( playerid , index , key[] )
{
    if(!IsPlayerNPC(playerid))
    {
        new name[23],file[30];
        GetPlayerName( playerid , name ,23 );
        format( file , 30 , "players/%s.ini" , name );
        new File:h1 = fopen( file , io_read );
        format( file , 30 , "%s.ini.tmp" , name );
        new File:h2 = fopen( file , io_write );
        for(new i = 1;i <= 10;i++)
        {
            if(i != index)
            {
                fread(h1,file);
                fwrite(h2,file);
            }
            else
            {
                fread(h1,file);
                format(file,30,"%s\r\n",key);
                fwrite(h2,file);
            }
        }
        fclose( h1 );
        fclose( h2 );
        format( file , 30 , "%s.ini.tmp" , name );
        h1 = fopen( file , io_read);
        format( file , 30 , "players/%s.ini" , name );
        h2 = fopen( file , io_write );
        while(fread(h1,file))
            fwrite(h2,file);
        fclose(h1);
        fclose(h2);
        format( file , 30 , "%s.ini.tmp" , name );
        fremove(file);
    }
}


forward pRemove( playerid );
public pRemove( playerid )
{
    if(!IsPlayerNPC(playerid))
    {
        new name[23],file[30];
        GetPlayerName( playerid , name ,23 );
        format( file , 30 , "players/%s.ini" , name );
        if (fexist(file))
            fremove(file);
    }
}
forward pExist( playerid );
public pExist( playerid )
{
    if(!IsPlayerNPC(playerid))
    {
        new name[23],file[30];
        GetPlayerName( playerid , name ,23 );
        format( file , 30 , "players/%s.ini" , name );
        if (fexist(file))
            return 1;
    }
    return 0;
}

forward cRegister( playerid  );
public cRegister( playerid  )
{

    new name[23],file[30];
    GetPlayerName( playerid , name ,23 );
    format( file , 30 , "players/%s.mods" , name );
    new File:h = fopen( file , io_write );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );

    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );

    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fclose( h );
}

stock cGet( playerid , index  )
{
    new name[23],file[30],key[30];
    GetPlayerName( playerid , name ,23 );
    format( file , 30 , "players/%s.mods" , name );
    new File:h = fopen( file , io_read );
    for(new i = 0;i < index; i++)
    {
        fread( h , key , 30 );
    }
    fclose( h );
    return key;
}

stock cbGet( playerid , index  )
{
    new file[30],key[30];
    format( file , 30 , "players/%s.mods" , Checkpoints[playerid][ename] );
    if(!fexist(file))
        return key;
    new File:h = fopen( file , io_read );
    for(new i = 0;i < index; i++)
    {
        fread( h , key , 30 );
    }
    fclose( h );
    return key;
}

forward cSet( playerid , index , key[] );
public cSet( playerid , index , key[] )
{
    new name[23],file[30];
    GetPlayerName( playerid , name ,23 );
    format( file , 30 , "players/%s.mods" , name );
    new File:h1 = fopen( file , io_read );
    format( file , 30 , "players/%s.mods.tmp" , name );
    new File:h2 = fopen( file , io_write );
    for(new i = 1;i <= 15;i++)
    {
        if(i != index)
        {
            fread(h1,file);
            fwrite(h2,file);
        }
        else
        {
            fread(h1,file);
            format(file,30,"%s\r\n",key);
            fwrite(h2,file);
        }
    }
    fclose( h1 );
    fclose( h2 );
    format( file , 30 , "players/%s.mods.tmp" , name );
    h1 = fopen( file , io_read);
    format( file , 30 , "players/%s.mods" , name );
    h2 = fopen( file , io_write );
    while(fread(h1,file))
        fwrite(h2,file);
    fclose(h1);
    fclose(h2);
    format( file , 30 , "players/%s.mods.tmp" , name );
    fremove(file);
}



forward rRegister( playerid , r );
public rRegister( playerid , r )
{
    new name[23],file[30];
    GetPlayerName( playerid , name ,23 );
    format( file , 30 , "%sx%d.r" , name ,r );
    new File:h = fopen( file , io_write );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fclose( h );
}

stock rGet( playerid , r ,index  )
{
    new name[23],file[30],key[30];
    GetPlayerName( playerid , name ,23 );
    format( file , 30 , "%sx%d.r" , name , r );
    new File:h = fopen( file , io_read );
    for(new i = 0;i < index; i++)
    {
        fread( h , key , 30 );
    }
    fclose( h );
    return key;
}

forward rSet( playerid , r , index , key[] );
public rSet( playerid , r , index , key[] )
{
    new name[23],file[30];
    GetPlayerName( playerid , name ,23 );
    format( file , 30 , "%sx%d.r" , name ,r);
    new File:h1 = fopen( file , io_read );
    format( file , 30 , "%sx%d.r.tmp" , name , r);
    new File:h2 = fopen( file , io_write );
    for(new i = 1;i <= 18;i++)
    {
        if(i != index)
        {
            fread(h1,file);
            fwrite(h2,file);
        }
        else
        {
            fread(h1,file);
            format(file,30,"%s\r\n",key);
            fwrite(h2,file);
        }
    }
    fclose( h1 );
    fclose( h2 );
    format( file , 30 , "%sx%d.r.tmp" , name,r  );
    h1 = fopen( file , io_read);
    format( file , 30 , "%sx%d.r" , name,r );
    h2 = fopen( file , io_write );
    while(fread(h1,file))
        fwrite(h2,file);
    fclose(h1);
    fclose(h2);
    format( file , 30 , "%sx%d.r.tmp" , name,r );
    fremove(file);
}
forward bRegister( playerid);
public bRegister( playerid )
{
    new name[23],file[30];
    GetPlayerName( playerid , name ,23 );
    format( file , 30 , "players/%s.bot" , name );
    new File:h = fopen( file , io_write );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fwrite(h , "0\r\n" );
    fclose( h );
}

stock bGet( playerid , index  )
{
    new name[23],file[30],key[30];
    GetPlayerName( playerid , name ,23 );
    format( file , 30 , "players/%s.bot" , name );
    new File:h = fopen( file , io_read );
    for(new i = 0;i <= index; i++)
    {
        fread( h , key , 30 );
    }
    fclose( h );
    strdel(key, strlen(key)-1,strlen(key));
    return strval(key);
}

forward bSet( playerid , index , key );
public bSet( playerid , index , key )
{
    new name[23],file[30];
    GetPlayerName( playerid , name ,23 );
    format( file , 30 , "players/%s.bot" , name );
    new File:h1 = fopen( file , io_read );
    format( file , 30 , "%s.bot.tmp" , name );
    new File:h2 = fopen( file , io_write );
    for(new i = 0;i < 50;i++)
    {
        if(i != index)
        {
            fread(h1,file);
            fwrite(h2,file);
        }
        else
        {
            fread(h1,file);
            format(file,30,"%d\r\n",key);
            fwrite(h2,file);
        }
    }
    fclose( h1 );
    fclose( h2 );
    format( file , 30 , "%s.bot.tmp" , name );
    h1 = fopen( file , io_read);
    format( file , 30 , "players/%s.bot" , name );
    h2 = fopen( file , io_write );
    while(fread(h1,file))
        fwrite(h2,file);
    fclose(h1);
    fclose(h2);
    format( file , 30 , "%s.bot.tmp" , name );
    fremove(file);
}


forward ShowDialog( playerid , dialogid , style , caption[] , info[] , button1[] , button2[] );
public ShowDialog( playerid , dialogid , style , caption[] , info[] , button1[] , button2[] )
{
    static dialogs = 0;
    if(style != 2)
    {
        for(new i = 0;i <= strlen(info);i++)
            if(info[i] == '\n')
                info[i] = ' ';

        new n = 0,max_len = 50;
        for(new i = max_len;strlen(info) > i;i+=50)
            n++;
        for(new i = 0;i < n;i++)
        {
            new pos = 0;
            for(new j = max_len*(i+1);j > max_len*(i);j--)
                if(info[j] == ' ')
                {
                    pos = j;
                    break;
                }
            info[pos] = '\n';
        }
    }
    ShowPlayerDialog(  playerid , dialogs++ , style , caption , info , button1, button2 );
    CurrentDialog[playerid]  = dialogid;
}

new shouldCameraRotate[ MAX_PLAYERS ] = 0;

forward StartCameraRot( playerid , Float:x , Float:y , Float:z, Float:distance );
public StartCameraRot( playerid , Float:x , Float:y , Float:z, Float:distance )
{
    shouldCameraRotate[ playerid] = 1;
    RotateCamera( playerid , x , y ,z, distance );
}

forward StopCameraRot( playerid );
public StopCameraRot( playerid )
{
    shouldCameraRotate[playerid] = 0;
}


new playerAngle[MAX_PLAYERS];
forward RotateCamera( playerid , Float:x , Float:y ,Float:z, Float:distance );
public RotateCamera( playerid , Float:x , Float:y ,Float:z, Float:distance )
{
    if(IsPlayerConnected( playerid ))
    if( shouldCameraRotate[playerid] == 1)
    {
        SetPlayerCameraPos( playerid , getXfromDistance( x , distance , playerAngle[playerid]+=1 ) , getYfromDistance( y , distance , playerAngle[playerid]+=1) ,z );
        SetPlayerCameraLookAt( playerid , x , y , z );
        SetTimerEx("RotateCamera", 50,0,"iffff",playerid,x,y,z,distance);
    }
    else
        SetCameraBehindPlayer(playerid);
}

forward Shop( playerid );
public Shop( playerid )
{
    Message(playerid,"Use Q and E to switch between cars. SPACEBAR to choose.");
    TogglePlayerControllable( playerid , 0 );
    StartCameraRot( playerid , 404.0320,2450.8276,16.0675 , 8 );
    ShowCar( playerid , 1 );
}

forward ShowCar( playerid , car );
public ShowCar( playerid , car )
{
    SetPlayerVirtualWorld( playerid , 1000 + car );
//  new str[24];
//  valstr(str,GetPlayerVirtualWorld(playerid));
//  SendClientMessage(playerid,0xFFFFFFAA,str);
    PutPlayerInVehicle( playerid , car , 0 );
    HideTextDraws( playerid );
    TextDrawShowForPlayer( playerid , CarStats[car-1] );
}

stock HideTextDraws( playerid )
{
    for(new i = 0;i < sizeof(CarStats);i++)
    {
        TextDrawHideForPlayer( playerid , CarStats[i] );
    }
}

stock GetModelCost( model )
{
    for(new i = 1;i < sizeof( cars );i++)
    {
        if(cars[i][emodel] == model )
        {
            return cars[i][ecost]*80/100;
        }
    }
    return 0;
}

stock PurchaseCar( playerid )
{
    if(pCar[playerid])
        DestroyVehicle(pCar[playerid]);
    cRegister(playerid);
    TogglePlayerControllable( playerid , 1 );
    StopCameraRot( playerid );
    SetPlayerVirtualWorld( playerid , 0 );
    SetVehicleVirtualWorld( GetPlayerVehicleID(playerid) , 0 );
    new str[30];
    new prcar = strval(pGet(playerid,4));
    valstr( str , GetVehicleModel( GetPlayerVehicleID( playerid ) ));
    pSet( playerid , 4 , str );
    new colors[] = { 85 ,0, 5, 2, 16,100,122,7 };
    new r = colors[random(sizeof(colors))];
    valstr(str,r);
    pSet( playerid , 5 , str );
    valstr(str,random(128));
    pSet( playerid , 6 , str );
    LoadPlayerCar( playerid );
    SpawnCar( playerid );
    PlayerPlaySound(playerid,BIKE_BOUGHT_SOUND,0,0,0);
    Message(playerid,"You have successfully bought your car.");
    SetPlayerScore(playerid,GetPlayerLevel(playerid));
    if(prcar == 0)
    {
        // registered
        TextDrawShowForPlayer( playerid , WWW );
    }
}

new Float:Spawns[][] =
{
{1350.2006,389.9850,19.2378,157.5106}, // HEY
{607.5723,355.6186,18.7613,32.0628}, //
{925.3957,-177.6983,10.3762,87.0313}, //
{-2631.2341,812.2899,49.6650,88.9850}, //
{-2810.6567,210.1268,6.8628,181.7626}, //
{-2623.9294,-210.3415,4.0132,269.3256}, //
{-2705.7175,181.3133,4.0113,357.6360}, //
{-1699.6893,354.3882,6.8630,133.2885}, //
{-2921.9678,-1831.8700,29.3273,6.2612}, //
{-2177.2043,-346.2129,35.5333,268.5878}, //
{-2066.9409,29.4541,35.0035,89.2554}, //
{-2146.0359,213.5417,35.0138,1.2273},
{-2006.6510,545.4361,34.7930,359.3970},
{-1629.4890,1237.2261,6.8707,43.8990},
{-2139.7600,1099.6354,79.6323,180.8249},
{-2142.6711,570.2026,34.8013,90.5770},
{-1979.2988,464.3108,28.6751,358.2176},
{-1539.7924,-2835.7673,46.7076,43.3757},
{563.4729,2657.7019,43.1600,268.8928}, // x
{1090.3818,-1710.9321,12.9541,270.9924}, // x
{-1960.4642,729.4062,44.8616,269.1235}, // x
{-1671.4374,1828.9480,25.3521,273.8797}, // y
{2723.7971,2116.9739,6.3040,353.4175}, // y
{1008.1245,2181.4863,10.2350,357.9573}, // y
{-2005.9696,346.2114,34.5748,359.9951}, // y
{-2259.7654,555.7224,34.5804,2.1286}, // y
{-323.0998,-1773.7679,16.4800,339.7993}, // y
{1710.9725,-501.8680,33.4012,12.2517}, // y
{1719.6974,438.7711,30.5329,341.3650}, // y
{1356.5258,-1353.7417,12.9459,359.2041}, // y
{2073.3894,2023.1129,10.2373,89.6916}, // -x
{1537.6943,1974.1000,10.2358,88.5552}, // -x
{1260.8429,1813.5625,11.4063,88.9063}, // -x
{-90.0562,2636.3435,63.4656,91.6635}, // -x
{-928.0897,2721.6904,45.4334,95.2190}, // -x
{1165.2596,-946.5063,42.5774,90.7340}, // -x
{-2316.0293,2674.2798,56.5460,88.6199}, // -x
{-572.0304,-2745.5669,66.0069,92.4541}, // x
{2125.8550,2073.3674,10.2350,179.3007}, // -y
{-2689.3984,1706.2052,67.1743,179.7256}, // -y
{-2004.7621,1010.9517,52.2581,179.7777}, // -y
{-1893.8807,102.3724,37.7039,175.2027}, // -y
{-2143.3687,906.7395,79.4178,179.5495}, // -y
{-1806.2354,119.8445,14.5272,183.5261}, // -y
{636.0094,-1418.0875,13.0378,179.9617}, // -y
{1047.0195,-1877.4255,12.7348,182.5248}, // -y
{-2605.2988,-474.7174,68.2396,275.8958},
{-1436.8602,-308.8750,5.5718,50.2420},
{-1941.5498,-1146.3855,14.7106,201.6289},
{-1277.7795,-1715.7827,45.4902,226.8159},
{-605.6245,-1207.3436,20.8614,154.3487},
{-463.2079,281.0801,1.6413,270.7617},
{-2004.3188,702.8160,44.8625,0.1591},
{-1672.4172,731.7435,19.3116,271.0173},
{-1699.1759,929.5253,24.3018,89.8111},
{-1712.5168,1044.5073,44.6279,358.2414},
{-2854.1238,453.5577,3.9249,183.1889},
{-2264.8030,565.5635,34.5812,269.8132},
{562.8450,2267.6921,33.9044,196.0807},
{1010.5961,1386.6401,10.2374,178.3798},
{1966.8695,39.7845,32.0774,275.4093},
{-1798.1310,-227.1539,17.7919,359.7192},
{-2256.1558,-228.3671,36.0269,176.8635},
{-2188.3320,505.4270,34.5788,86.5070},
{-2433.0920,1374.7974,6.6022,269.6667},
{682.7741,-155.1761,23.1781,82.9765},
{708.7162,317.3557,19.4460,279.2621},
{-2705.7036,262.9774,3.7452,0.0536}

};

stock SpawnCar( playerid )
{
    new v = pCar[playerid];
    PutPlayerInVehicle(playerid,v, 0);
    new r = random(sizeof(Spawns));
    SetVehiclePos( v , Spawns[r][0] , Spawns[r][1] , Spawns[r][2] );
    SetVehicleZAngle( v, Spawns[r][3]);
    new Float:x1,Float:y1;
    x1 = getXfromDistance( Spawns[r][0] , 1000 , Spawns[r][3] );
    y1 = getYfromDistance( Spawns[r][1] , 1000 , Spawns[r][3] );
    SetVehicleVelocity(v,(Spawns[r][0]-x1)/(1000),(y1-Spawns[r][1])/(1000),-0.1);
    Attach3DTextLabelToVehicle(DDD[playerid],v,0,0,0);
    printf("vehicleid %d",v);
    Attach3DTextLabelToPlayer(DDD2[playerid],playerid,0,0,0);
    SetVehicleHealth(v,9999999999);
    SetCameraBehindPlayer(playerid);
    PlayerPlaySound(playerid,RESPAWN_SOUND,0,0,0);
}

stock LoadPlayerCar( playerid )
{
    new v = strval(pGet( playerid , 4 ));
    new c1 = strval(pGet( playerid , 5 ));
    new c2 = strval(pGet( playerid , 6 ));

    new c = CreateVehicle( v , 0 , 0 , 0 , 0 , c1 , c2 , -1 );
    SetPlayerColor(playerid,GetPlayerColorFromCarColor( c1 ));
//  printf("carid %d model %d",c,v);
    for(new i = 0;i <= 13;i++)
    {
        new t = strval(cGet( playerid , i+1 ));
        if(t)
            AddVehicleComponent(c,t);
    }
    new paintjob = strval(cGet(playerid,15));
    if(paintjob != 0)
    {
        ChangeVehiclePaintjob( c , paintjob-1 );
        SetPlayerColor(playerid,COLOR_WHITE);
    }
    PutPlayerInVehicle( playerid , c , 0 );
    pCar[playerid] = c;
    SetNitrox( playerid , 100 );
    TextDrawShowForPlayer( playerid , HUD );
    TextDrawShowForPlayer( playerid , NitroBar[playerid] );
    TextDrawShowForPlayer( playerid , SpeedBar[playerid] );

}

forward ManageVehicle();
public ManageVehicle()
{
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerInAnyVehicle(i))
        if(IsPlayerConnected(i))
        {
            if(!IsPlayerNPC(i))
            {
                if(GetKeys(i) != 12)
                {
                    new n = GetNitrox(i);
                    SetNitrox(i,n+1);
                }
            }
            if(GetPlayerState(i)==PLAYER_STATE_DRIVER)
            {
                new Float:h;
                GetVehicleHealth(GetPlayerVehicleID(i),h);
                if(h < 1000)
                {
                    new Float:Z;
                    new v = GetPlayerVehicleID(i);
                    GetVehicleZAngle(v,Z);
                    SetVehicleZAngle( v,Z);
//                  printf("Z %f",Z);
                    SetVehicleHealth(v,9999999999);
                }

                //SetPlayerArmour(i,(2*(h-500))/10);
            }
            else
            {
                //SetPlayerArmour(i,0);
            }
        }
    }
}

forward HeatPause(playerid);
public HeatPause(playerid)
{
    GameTextForPlayer(playerid,"~n~~n~~n~~n~~r~NO FUEl!" , 10000 , 5);
    TogglePlayerControllable( playerid , 0);
    FixPlayerHeat(playerid);
}

forward FixPlayerHeat(playerid);
public FixPlayerHeat( playerid )
{
    if((GetPlayerState(playerid)==PLAYER_STATE_DRIVER))
    {
        new Float:h;
        GetPlayerArmour(playerid,h);
        if(h < 5)
            SetPlayerArmour(playerid,5);
        else
            SetPlayerArmour(playerid,h+2);
        if(h < 48)
            SetTimerEx("FixPlayerHeat",500,0,"i",playerid);
        else
        {
            TogglePlayerControllable(playerid,1);
            SetPlayerArmour(playerid,50);
        }
    }
    else
        TogglePlayerControllable(playerid,1);
}
stock Push(v,speed)
{
    new Float:x,Float:y,Float:z,Float:a;
    GetVehiclePos( v , x,y,z);
    GetVehicleZAngle( v, a);
    new Float:x1,Float:y1;
    x1 = getXfromDistance( x , 1000 , a );
    y1 = getYfromDistance( y , 1000 , a );
    SetVehicleVelocity(v,(x-x1)/(1000*speed),(y1-y)/(1000*speed),0);
}

new toldU[MAX_PLAYERS][sizeof Checkpoints];
forward RaceManager();
public RaceManager()
{
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerInAnyVehicle(i))
        if(IsPlayerConnected(i))
        {
            if(!IsPlayerNPC(i))
            {
            /*
                for(new j = 0; j < MAX_PLAYERS;j++)
                {
                    if(j < max_checkpoints)
                    if(IsPlayerNPC(j))
                    {
                        if(bGet(i,j)==0)
                        if(GetDistanceBetweenPlayers(i,j) < 15)
                        {
                            if((Race[i] == -1) && (Race[j] == -1))
                            {
                                if(DidUask[i] == j)
                                {
                                    DidUask[i] = -1;
                                    continue;
                                }

                                DidUask[i] = j;
                                SendPlayerMessageToPlayer(i,j,WannaRace[random(sizeof(WannaRace))]);
                                break;
                            }
                        }
                    }
                }
            */
                new j = GetClosestBot(i);
                printf("closest bot %d",j);
                if(j != -1)
                {
                    if(GetPlayerVirtualWorld(j) == 0)
                    if(bGet(i,j)==1)
                    {
                        if(toldU[i][j] != 1)
                        {
                            SendPlayerMessageToPlayer(i,j,"You already won me out :(.");
                            toldU[i][j] = 1;
                        }
                    }
                    else
                    if(GetDistanceBetweenPlayers(i,j) < 15)
                    {
                        if((Race[i] == -1) && (Race[j] == -1))
                        {
                            if(GetPlayerVirtualWorld(i) == GetPlayerVirtualWorld(j))
                            {
                                if(DidUask[i] == j)
                                {
                                   // DidUask[i] = -1;
                                    continue;
                                }
                                DidUask[i] = j;
                                SendPlayerMessageToPlayer(i,j,WannaRace[random(sizeof(WannaRace))]);
                                Message(i,"Press 'H' to accept.");
                            }
                        }
                    }
                }
            }
        }
    }
}

public OnPlayerClickPlayer(playerid, clickedplayerid, source)
{
    new i = clickedplayerid;
    if(GetPlayerVirtualWorld(playerid))
        return Message(playerid,"You can't teleport to there right now.");
    if(GetPlayerVirtualWorld(i))
        return Message(playerid,"You can't teleport to there right now.");
    if(Race[playerid] != -1)
        return Message(playerid,"You can't teleport to there right now.");
    if(Race[i] != -1)
        return Message(playerid,"You can't teleport to there right now.");
    if(mpRace[playerid] == 1)
        return Message(playerid,"You can't teleport to there right now.");
    if(mpRace[i] == 1)
        return Message(playerid,"You can't teleport to there right now.");
    if(playerid == clickedplayerid)
        return Message(playerid,"You can't teleport to yourself.");

    new Float:x,Float:y,Float:z;
    new v1,v2;
    v1 = GetPlayerVehicleID(i);
    v2 = GetPlayerVehicleID(playerid);
    GetVehiclePos(v1,x,y,z);
    SetVehiclePos(v2,x,y,z+5);
    GetVehicleZAngle(v1,z);
    SetVehicleZAngle(v2,z);
    GetVehicleVelocity(v1,x,y,z);
    SetVehicleVelocity(v2,x/2,y/2,z/2);
    return 1;
}


forward UpdateDisks();
public UpdateDisks()
{
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerInAnyVehicle(i))
        if(IsPlayerConnected(i))
        {
            if(!IsPlayerNPC(i))
            {
                if(ignordisk[i] == 0)
                if(random(2)==1)
                    CreateDisk( i );
            }
        }
    }
}

forward UpdateVelocity();
public UpdateVelocity()
{
    new str[20];
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerConnected(i))
        {
            if(IsPlayerInAnyVehicle(i))
            {
                new Float:v,Float:x,Float:y,Float:z;
                GetVehicleVelocity(GetPlayerVehicleID(i),x,y,z);
                if(x < 0) x = x + -x + -x;
                if(y < 0) y = y + -y + -y;
                if(z < 0) z = z + -z + -z;
                v = ((x * 1) + (y * 1) + (z * 1))*70;
                format(str,20,"\n\n%.2fkmph",v);
                Update3DTextLabelText(DDD[i],GetPlayerColor(i),str);
                SetSpeed(i,floatround(v));
                SetPlayerHealth( i , 1000 ); // manage health
            }
        }
    }
}



forward UpdateCheckpoints(i);
public UpdateCheckpoints(i)
{
    if(Race[i] != -1)
    {
        new r = GetCheckpointId(Race[i]);
        new Float:x,Float:y,Float:z;
        GetPlayerPos(i,x,y,z);
        new Float:d = GetDistance( x, y,z, Checkpoints[r][ex2], Checkpoints[r][ey2], Checkpoints[r][ez2]);
        new str[10];
        format(str,10,"%.2f",d);
//      UpdatePlayer3DTextLabelText(i,Dist[i],0xAA3333AA,str);
        SetTimerEx("UpdateCheckpoints",100,0,"i",i);
        //printf(" 3d for %d ",i );
    }
    else
    {
//      DeletePlayer3DTextLabel( i , Dist[i] );
    }
}


forward RecordRaceCheckpoint( playerid, bot[] );
public RecordRaceCheckpoint( playerid,bot[] )
{
    if(IsPlayerConnected(playerid))
    {
        new Float:x,Float:y, Float:z;
        GetPlayerPos( playerid , x, y , z);
        CreatePickup( 1239,2,x,y,z,0);
        new string[128];
        format(string,128,"%s.cp",bot);
        if(timetaken == 0)
        {
            hbot = fopen( string , io_write);
            SendClientMessage( playerid , 0xFFFFFFAA , string );
        }
        format(string,128,"%f , %f , %f\r\n",x,y,z);
        fwrite(hbot,string);
        timetaken+=4;
        format(string,128,"~n~~n~~n~~n~%d:%d",timetaken / 60,timetaken % 60 );
        GameTextForPlayer( playerid , string , 4000 , 5 );
    }
    else
    {
        KillTimer(timerforcp);
        OnPlayerExitVehicle(playerid,0);
    }
}

forward MultiplayerRaceManagement();
public MultiplayerRaceManagement()
{
    new r;
    new Float:v;
    do
    {
        r = random(max_checkpoints);
        new Float:x,Float:y,Float:z;
        GetVehicleVelocity(Checkpoints[GetCheckpointId(r)][ev],x,y,z);
        if(x < 0) x = x + -x + -x;
        if(y < 0) y = y + -y + -y;
        if(z < 0) z = z + -z + -z;
        v = ((x * 1) + (y * 1) + (z * 1))*70;

    }
    while(v != 0);
    MPCounter = 0;
    Ride_mp( r );
//  CallRemoteFunction("Ride_mp","s",Checkpoints[r][ename]);
}

forward Ride_mp(r);
public Ride_mp(r)
{
    if(IsPlayerConnected(mp))
    {
        SetPlayerVirtualWorld( mp , 0 );
        SetVehicleVirtualWorld( Checkpoints[GetCheckpointId(r)][ev] , 0 );
    }
    mp = Checkpoints[r][eid];
    Finishmp = 0;
    SetPlayerVirtualWorld( (r) , 2099 ); // get him back after race
    SetVehicleVirtualWorld( Checkpoints[GetCheckpointId(r)][ev] , 2099 ); // get him back after race
    new m = random(24) + 1;
    Prizemp[0] = m * 100;
    Prizemp[1] = (m * 100)/2;
    Prizemp[2] = (m * 100)/4;
    for(new i = 0;i < MAX_PLAYERS; i++)
    {
        if(IsPlayerConnected( i ))
        {
            if(!IsPlayerNPC( i ))
            {
                if(Race[i] == -1)
                {

                    new string[256];
                    format(string,256,"A Multiplayer race is going to start shortly. Cash Prize: $%d. Press 2 to join.",m*1000);
                    Message( i , string);
                }
            }
        }
    }
}

forward UpdateFuel();
public UpdateFuel()
{
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerConnected(i))
        if(!IsPlayerNPC(i))
        {
            if(IsPlayerInAnyVehicle(i))
            {
                new Float:v;
                GetPlayerArmour(i,v);
                SetPlayerArmour(i,v - 1);
                if(v == 0)
                {
                    HeatPause( i );
                }
                if(IsPlayerInFuelStation(i))
                {
                    new ud,lr,k;
                    GetPlayerKeys(i,k,ud,lr);
                    if((k == 0) && (ud == 0) && (lr == 0))
                    {
                        GetPlayerArmour(i,v);
                        SetPlayerArmour(i,v + 10);
                    }
                }
            }
        }
    }
}

stock IsPlayerInFuelStation(playerid)
{
    for(new i = 0;i < sizeof(FuelStations);i++)
    {
        if(IsPlayerInRangeOfPoint(playerid,6,FuelStations[i][0],FuelStations[i][1],FuelStations[i][2]))
            return 1;
    }
    return 0;
}

stock Message( playerid , info[])
{
//  static tim[MAX_PLAYERS];
//  KillTimer(tim[playerid]);
    TextDrawSetString( VertiDraw[playerid] , info );
    PlayerPlaySound(playerid,1055,0,0,0);
//  TextDrawShowForPlayer( playerid,VertiDraw[playerid]);
//  tim[playerid] = SetTimerEx("HideMessage",60 * 1000 , 0,"i",playerid);
    return 1;
}

forward HideMessage(playerid);
public HideMessage(playerid)
{
    TextDrawHideForPlayer( playerid,VertiDraw[playerid]);
}

stock writeracelog( playerid , line[] )
{
    if(IsPlayerNPC(playerid))
        return 0;
    new string[256];
    new name[23];
    GetPlayerName(playerid,name,23);
    format(string,256,"racelog/%s.log",name);
    if(!fexist(string))
        fclose(fopen(string,io_write));
    new File:h = fopen(string,io_read);
    format(string,256,"racelog/%s.tmp.log",name);
    new File:h2 = fopen(string,io_write);
    while(fread(h,string))
        fwrite(h2,string);
    fclose(h);
    fclose(h2);
    format(string,256,"racelog/%s.log",name);
    h = fopen(string,io_write);
    format(string,256,"racelog/%s.tmp.log",name);
    h2 = fopen(string,io_read);
    format(string,256,"%s\r\n",line);
    fwrite(h,string);
    while(fread(h2,string))
        fwrite(h,string);
    fclose(h);
    fclose(h2);
    format(string,256,"racelog/%s.tmp.log",name);
    fremove(string);
    return 1;
}


stock GetPlayerColorFromCarColor( color )
{
    switch(color)
    {
        case 0: return COLOR_BLACK;
        case 1: return COLOR_WHITE;
        case 2: return COLOR_BLUE;
        case 3: return COLOR_RED;
        case 4: return COLOR_GREY;
        case 5: return COLOR_LPINK;
        case 6: return COLOR_YELLOW;
        case 7: return COLOR_LBLUE;
        case 8: return COLOR_GREY;
        case 9: return COLOR_GREY;
        case 10: return COLOR_DBLUE;
        case 11: return COLOR_GREY;
        case 12: return COLOR_GREY;
        case 13: return COLOR_GREY;
        case 14: return COLOR_WHITE;
        case 15: return COLOR_GREY;
        case 16: return COLOR_LGREEN;
        case 17: return COLOR_LRED;
        case 18: return COLOR_LRED;
        case 19: return COLOR_GREY;
        case 20: return COLOR_DBLUE;
        case 21: return COLOR_MAROON;
        case 22: return COLOR_MAROON;
        case 23: return COLOR_GREY;
        case 24: return COLOR_GREY;
        case 25: return COLOR_GREY;
        case 26: return COLOR_GREY;
        case 27: return COLOR_GREY;
        case 28: return COLOR_DBLUE;
        case 29: return COLOR_GREY;
        case 30: return COLOR_BROWN;
        case 31: return COLOR_BROWN;
        case 32: return COLOR_LBLUE;
        case 33: return COLOR_GREY;
        case 34: return COLOR_GREY;
        case 35: return COLOR_GREY;
        case 36: return COLOR_BLACK;
        case 37: return COLOR_GREY;
        case 38: return COLOR_WHITE;
        case 39: return COLOR_LBLUE;
        case 40: return COLOR_BLACK;
        case 41: return COLOR_GREY;
        case 42: return COLOR_LRED;
        case 43: return COLOR_MAROON;
        case 44: return COLOR_DGREEN;
        case 45: return COLOR_MAROON;
        case 46: return COLOR_LYELLOW;
        case 47: return COLOR_GREY;
        case 48: return COLOR_GREY;
        case 49: return COLOR_WHITE;
        case 50: return COLOR_GREY;
        case 51: return COLOR_LGREEN;
        case 52: return COLOR_LBLUE;
        case 53: return COLOR_DBLUE;
        case 54: return COLOR_DBLUE;
        case 55: return COLOR_LRED;
        case 56: return COLOR_WHITE;
        case 57: return COLOR_LRED;
        case 58: return COLOR_RED;
        case 59: return COLOR_LBLUE;
        case 60: return COLOR_GREY;
        case 61: return COLOR_BROWN;
        case 62: return COLOR_RED;
        case 63: return COLOR_GREY;
        case 64: return COLOR_GREY;
        case 65: return COLOR_LYELLOW;
        case 66: return COLOR_BROWN;
        case 67: return COLOR_LBLUE;
        case 68: return COLOR_WHITE;
        case 69: return COLOR_WHITE;
        case 70: return COLOR_LRED;
        case 71: return COLOR_LBLUE;
        case 72: return COLOR_GREY;
        case 73: return COLOR_WHITE;
        case 74: return COLOR_MAROON;
        case 75: return COLOR_DGREEN;
        case 76: return COLOR_WHITE;
        case 77: return COLOR_WHITE;
        case 78: return COLOR_RED;
        case 79: return COLOR_DBLUE;
        case 80: return COLOR_LRED;
        case 81: return COLOR_GREY;
        case 82: return COLOR_LRED;
        case 83: return COLOR_DGREEN;
        case 85: return COLOR_PINK;
        case 86: return COLOR_GREEN;
        case 87: return COLOR_BLUE;
        case 88: return COLOR_LRED;
        case 89: return COLOR_WHITE;
        case 90: return COLOR_WHITE;
        case 91: return COLOR_DBLUE;
        case 92: return COLOR_GREY;
        case 93: return COLOR_BLUE;
        case 94: return COLOR_DBLUE;
        case 95: return COLOR_DBLUE;
        case 96: return COLOR_WHITE;
        case 97: return COLOR_LBLUE;
        case 98: return COLOR_GREY;
        case 99: return COLOR_WHITE;
        case 100: return COLOR_BLUE;
        case 101: return COLOR_BLACK;
        case 102: return COLOR_LYELLOW;
        case 103: return COLOR_DBLUE;
        case 104: return COLOR_LRED;
        case 105: return COLOR_GREY;
        case 106: return COLOR_BLUE;
        case 107: return COLOR_WHITE;
        case 108: return COLOR_BLUE;
        case 109: return COLOR_GREY;
        case 110: return COLOR_WHITE;
        case 111: return COLOR_GREY;
        case 112: return COLOR_LBLUE;
        case 113: return COLOR_GREY;
        case 114: return COLOR_LGREEN;
        case 115: return COLOR_LRED;
        case 116: return COLOR_DBLUE;
        case 117: return COLOR_RED;
        case 118: return COLOR_WHITE;
        case 119: return COLOR_GREY;
        case 120: return COLOR_GREY;
        case 121: return COLOR_RED;
        case 122: return COLOR_GREY;
        case 123: return COLOR_BROWN;
        case 124: return COLOR_LRED;
        case 125: return COLOR_DBLUE;
        case 126: return COLOR_PINK;
        case -1: return COLOR_BOT;
    }
    return  COLOR_WHITE;
}

stock addadmin( name[] )
{
    if(!fexist("admins.txt"))
        fclose(fopen("admins.txt",io_write));
    new File:h = fopen("admins.txt",io_append);
    new string[256];
    format(string,256,"%s\r\n",name);
    fwrite(h,string);
    fclose(h);
}

stock deladmin( name[] )
{
    if(!fexist("admins.txt"))
        fclose(fopen("admins.txt",io_write));
    new File:h = fopen("admins.txt",io_read);
    new File:h2 = fopen("admins.tmp.txt",io_write);
    new string[256];
    while(fread(h,string))
    {
        if(strcmp(string,name,true,strlen(name))!=0)
            fwrite(h2,string);
    }
    fclose(h);
    fclose(h2);
    h = fopen("admins.txt",io_write);
    h2 = fopen("admins.tmp.txt",io_read);
    while(fread(h2,string))
        fwrite(h,string);
    fclose(h);
    fclose(h2);
    fremove("admins.tmp.txt");
}

stock isadmin( playerid )
{
    new name[23];
    GetPlayerName(playerid,name,23);
    if(!fexist("admins.txt"))
        fclose(fopen("admins.txt",io_write));
    new File:h = fopen("admins.txt",io_read);
    new string[256];
    while(fread(h,string))
    {
        if(strcmp(string,name,true,strlen(name))==0)
        {
            fclose(h);
            return 1;
        }
    }
    fclose(h);
    return 0;
}

stock SetNitrox( playerid  , amount )
{
    if(amount < 0)
        amount = 0;
    if(amount > 100)
        amount = 100;
    Nitrox[playerid ]  = amount;
    SetNitroBar( playerid , amount );
}

stock SetSpeed( playerid  , amount )
{
    if(amount < 0)
        amount = 0;
    if(amount > 100)
        amount = 100;
    SetSpeedBar( playerid , amount );
}

stock SetSpeedBar( playerid , progress)
{
    new string[128];
    for(new i = 0;i < progress+3;i++)
    {
        if(progress > 0)
        if(i == 0)
            strins(string,"~",i);
        else if(i == 1)
        {
            if(progress > 95)
                strins(string,"r",i);
            else if(progress > 80)
                strins(string,"y",i);
            else
                strins(string,"g",i);


        }
        else if(i == 2)
            strins(string,"~",i);
        else
            strins(string,"l",i);

    }
    TextDrawSetString( SpeedBar[playerid] , string );
}

stock SetNitroBar( playerid , progress)
{
    new string[128];
    for(new i = 0;i < progress+3;i++)
    {
        if(progress > 0)
        if(i == 0)
            strins(string,"~",i);
        else if(i == 1)
        {
            if(progress > 60)
                strins(string,"g",i);
            else if(progress > 20)
                strins(string,"y",i);
            else if(progress > 0)
                strins(string,"r",i);

        }
        else if(i == 2)
            strins(string,"~",i);
        else
            strins(string,"l",i);

    }
    TextDrawSetString( NitroBar[playerid] , string );
}
stock GetNitrox( playerid )
{
    return Nitrox[playerid ];
}

stock GetKeys( playerid )
{
    return pKey[playerid];
}

forward UpdateVehicleBots();
public UpdateVehicleBots()
{
    for(new i = 0;i < MAX_PLAYERS;i++)
    {
        if(IsPlayerConnected(i))
        if(!IsPlayerNPC(i))
        {
            if(IsPlayerInAnyVehicle(i))
            {
                if(Race[i] == -1)
                {
                    if(mpRace[i] == 0)
                    {
                        if(GetPlayerVirtualWorld(i) == 0)
                        {
                            for(new j = 0;j <MAX_VEHICLES;j++)
                            {
                                if(IsVehicleStreamedIn(j,i))
                                {
                                    if(GetVehicleDriver(j) == -1)
                                    {
                                        new vehicleid = j;
                                        new forplayerid = i;
                                        for(new k = 0;k < max_checkpoints;k++)
                                        {
                                            if(Checkpoints[k][ev] == vehicleid)
                                            {
                                                if(GetVehicleDriver(vehicleid) == -1)
                                                {
                                                    new n = GetFreeNPC();
                                                    if(n != -1)
                                                    {
                                                        FreeNPC[n] = 0;
                                                        SetPlayerVirtualWorld(n,0);
                                                        PutPlayerInVehicle(n,vehicleid,0);
                                                        new string[30];
                                                        SetPlayerName(n,Checkpoints[k][ename]);
                                                        SetPlayerSkin(n,Checkpoints[k][eskin]);
                                                        GivePlayerMoney(n,100000+random(9023480));
                                                        format(string,30,"finish %s",Checkpoints[k][ename]);
                                                        printf(string);
                                                        SendClientMessage(n,0,string);
                                                        Checkpoints[k][eid] = n;
                                                    }
                                                }
                                            }
                                        }
                                    }

                                }
                            }
                        }
                    }
                }
            }
        }
    }
}