View difference between Paste ID: Wg9di3hb and XjPaftak

 // Includes necessárias
 #include <a_samp>
 #include <DOF2>
 #include <foreach>
 #include <Pawn.CMD> // Se quiser utilizar zcmd ou semelhante, fique à vontade.
 #include <sscanf2>
 
 // Cores
 #define Vermelho                                                                0xFF0000AA
 #define Verde                                                                   0x00D700AA
 #define Azul                                                                    0x00FFFFAA
 #define Amarelo                                                                 0xFFFFFFAA
 #define LARANJA                                                                 0xFFFF00AA
 
 // Sistema de Corrida
 enum CRInfo
 {
 	Float: PosCorrida[3],
 	GangZoneCorrida,
 	bool: CorridaAtivo,
 	NomeCorrida[30],
 	VagasCorrida,
 	PlayersCorrida,
 	Text: TextDrawsCorrida[3],
 	Int_Corrida,
 	Virtual_World,
 	bool: CorridaCongelado,
 	CorridaVida,
 	Corridakev,
 	TotalCP,
 	bool: IsRace,
 	bool: CorridaIniciado,
 	bool: CorridaTrancado,
 	Organizador[MAX_PLAYER_NAME],
 	Vencedores,
 	TimerRandom,
 	TimerIniciar,
 	Contagem,
 	Tempo,
 	InicioRandomico,
 	bool: VagasOcupadas[50],
 	CPStyle
 };
 
 // Info corrida
 #define MAX_CorridaS 															100
 #define MAX_CPS	 																200
 #define VIRTUAL_WORLD 															80
 #define CorridaText
 #define PASTA_Corrida "/Corridas/Corrida%d.ini" // Crie a pasta com o nome "Corridas" sem aspas na pasta scriptfiles de sua Gamemode.
 
 enum CarrosInfo
 {
 	VehID,
 	Float:CoordY,
 	Float:CoordX,
 	Float:CoordZ,
 	Float:Angulo
 };
 
 
 // Var
 #if defined CorridaText
 new Text:Text_Corrida;
 #endif
 
 new timer;
 
 #if defined CorridaText
 new NewsLine[][] =
 {
     "~b~Corrida ~y~ativada   ~n~ ~r~use ~g~/ircorrida",
 	"~y~Corrida ~b~ativada   ~n~ ~g~use ~r~/ircorrida"
 
 };
 #endif
 
 new Float:CarrosInfos[MAX_PLAYERS][CarrosInfo];
 new Float:CheckPoint[MAX_PLAYERS][MAX_CPS][3];
 new CarroCorrida[MAX_PLAYERS] = INVALID_VEHICLE_ID;
 new ListaCorrida[MAX_PLAYERS][MAX_CorridaS];
 new Float:CPCoord[MAX_CPS][3];
 new Float:VeiculoCoord[MAX_PLAYERS][4];
 new VeiculoModel[MAX_PLAYERS];
 new VeiculoCorrida[MAX_PLAYERS];
 new IsPlayerCountdownStarted[MAX_PLAYERS];
 new PlayerCountdownCount[MAX_PLAYERS];
 new PlayerCountdownTimer[MAX_PLAYERS];
 new IsCountdownStarted;
 // Corrida
 new interiorc;
 new Proibido = 1;
 new CorridaTextDraw = 0;
 new CorridaCriado = 0;
 new VagasNaCorrida = 0;
 new PlayersNaCorrida = 0;
 new Online = 0;
 new ExpulsoCorrida[MAX_PLAYERS] = 0;
 new Float:cX;
 new Float:cY;
 new Float:cZ;
 new guerra;
 new noCorrida[MAX_PLAYERS];
 
 // Forwards
 forward RaceTextUpdate(playerid);
 forward IsNumeric(const string[]);
 
 // Dialogs
 #define DIALOG_CRIAR_Corrida 													0
 #define DIALOG_CRIAR_POSICAO 													1
 #define DIALOG_DEFINIR_VAGAS 													2
 #define DIALOG_CONFIGS 															3
 #define DIALOG_Corrida_PERSONALIZADO	 										4
 #define DIALOG_NOME_CORRIDA 													5
 #define DIALOG_CARREGAR_Corrida 												6
 #define DIALOG_DELETAR_Corrida 													7
 #define DIALOG_VIRTUAL_WORLD_Corrida 											8
 #define DIALOG_DEFINIR_CHECK 													9
 
 new E_Enum[CRInfo];
 new StringEV[128];
 
 new vid[MAX_PLAYERS] = INVALID_VEHICLE_ID;
 
 public OnGameModeExit() {
 	DOF2_Exit();
 	return 1;
 }
 
 public OnPlayerConnect(playerid) {
 	Online++;
 	return 1;
 }
 
 CMD:cv(playerid, params[]) { // Comando para criar veículo simples para salvar ao criar uma corrida.
 	new Float:X, Float:Y, Float:Z, Float:Angle, model;
 
 	if(sscanf(params, "d", model)) return SendClientMessage(playerid, Vermelho, "Use: /cv [id]");
 
 	GetPlayerPos(playerid, X, Y, Z);
 	GetPlayerFacingAngle(playerid, Angle);
 	if(vid[playerid] != INVALID_VEHICLE_ID) DestroyVehicle(vid[playerid]);
 
 
 	vid[playerid] = AddStaticVehicleEx(model, X, Y, Z, Angle, 0, 0, 30);
 	PutPlayerInVehicle(playerid, vid[playerid], 0);
 	LinkVehicleToInterior(vid[playerid], GetPlayerInterior(playerid));
 	SetVehicleVirtualWorld(vid[playerid], GetPlayerVirtualWorld(playerid));
 	return 1;
 }
 
 public OnPlayerStateChange(playerid, newstate, oldstate) {
 	if(oldstate == PLAYER_STATE_DRIVER && newstate == PLAYER_STATE_ONFOOT && vid[playerid] != INVALID_VEHICLE_ID) DestroyVehicle(vid[playerid]);
 	return 1;
 }
 
 CMD:criarcorrida(playerid, params[])
 {
 	if(!IsPlayerAdmin(playerid)) return SendClientMessage(playerid, Vermelho, "Você não tem permissão para usar esse Comando.");
 	if(E_Enum[CorridaAtivo] == true) return SendClientMessage(playerid, Vermelho, "-> Já existe uma corrida ativada.");
 	if(GetPVarInt(playerid, "CriandoCorridaPersonalizado")) return SendClientMessage(playerid, Vermelho, "-> Você está criando um circuito, termine-o primeiro.");
 	ShowPlayerDialog(playerid, DIALOG_CRIAR_Corrida, DIALOG_STYLE_LIST, "Criar Corrida", "Criar Corrida\nCarregar Corrida", "Selecionar", "Voltar");
 	return 1;
 }
 
 CMD:expulsarcorrida(playerid, params[]) {
 	new plid, motivo[64];
 	if(sscanf(params, "us[64]", plid, motivo)) return SendClientMessage(playerid, Vermelho, "/expulsarcorrida [id] [motivo]");
 	PlayerExpulsePlayerEvent(playerid, plid, motivo);
 	return 1;
 }
 
 CMD:ircorrida(playerid, params[]) {
 	if(E_Enum[CorridaAtivo] == false) return SendClientMessage(playerid, Vermelho, "-> Não há corrida disponivel no momento.");
 	if(GetPVarInt(playerid, "NoCorrida")) return SendClientMessage(playerid, Vermelho, "-> Você já está em uma corrida.");
 	if(GetPVarInt(playerid, "ExpulsoCorrida")) return SendClientMessage(playerid, Vermelho, "-> Você foi expulso da corrida.");
 	if(E_Enum[CorridaTrancado] == true) return SendClientMessage(playerid, Vermelho, "-> A corrida está trancada.");
 
 	SetPlayerEventPos(playerid);
 	return 1;
 }
 
 CMD:fecharcorrida(playerid, params[]) {
 	if(!IsPlayerAdmin(playerid)) return SendClientMessage(playerid, Vermelho, "-> Somente administrador pode usar este comando.");
 	if(IsOrganizador(playerid)) return 1;
 	PlayerClosetEvent(playerid);
 	return 1;
 }
 
 CMD:cancelarcorrida(playerid, params[]) {
 	if(!IsPlayerAdmin(playerid)) return SendClientMessage(playerid, Vermelho, "Você não possui permissão para utilizar este comando.");
 	if(IsOrganizador(playerid)) return 1;
 	PlayerCancelEvent(playerid);
 	return 1;
 }
 
 CMD:saircorrida(playerid, params[]) {
 	if(!GetPVarInt(playerid, "NoCorrida")) return SendClientMessage(playerid, Vermelho, "-> Você não está em uma corrida.");
 
 	DestroyVehicle(GetPlayerVehicleID(playerid));
 	SendClientMessage(playerid, Vermelho, "-> Você saiu da corrida.");
 	DisableRemoteVehicleCollisions(playerid, 0);
 
 	format(StringEV, sizeof(StringEV), "{4682B4}| {FFFFFF}CORRIDA {4682B4}| {FFFFFF}%s saiu da corrida, use: {4682B4}/saircorrida {FFFFFF}caso queira sair.", GetPlayerNameEx(playerid));
 	SendClientMessageToAll(-1, StringEV);
 
 	SpawnPlayer(playerid);
 	return 1;
 }
 
 CMD:veiculo(playerid, params[]) {
 	if(!IsPlayerAdmin(playerid)) return SendClientMessage(playerid, Vermelho, "Você não possui permissão para utilizar este comando.");
 	if(!GetPVarInt(playerid, "SaveVeiculo")) return SendClientMessage(playerid, Vermelho, "Você não está criando uma corrida.");
 	if(!IsPlayerInAnyVehicle(playerid)) return SendClientMessage(playerid, Vermelho, "Por favor, crie o veículo para salva-lo.");
 
 	new Float: vPos[4], Car = GetPlayerVehicleID(playerid), Modelo = GetVehicleModel(Car);
 	GetVehiclePos(Car, vPos[0], vPos[1], vPos[2]);
 	GetVehicleZAngle(Car, vPos[3]);
 
 	CarrosInfos[GetPVarInt(playerid, "VID")][CoordX] = vPos[0];
 	CarrosInfos[GetPVarInt(playerid, "VID")][CoordY] = vPos[1];
 	CarrosInfos[GetPVarInt(playerid, "VID")][CoordZ] = vPos[2];
 	CarrosInfos[GetPVarInt(playerid, "VID")][Angulo] = vPos[3];
 	CarrosInfos[GetPVarInt(playerid, "VID")][VehID] = Modelo;
 
 	SetTimerEx("CriarVeiculoCorrida", 2000, false, "ddffff", playerid, Modelo, vPos[0], vPos[1], vPos[2], vPos[3]);
 	SendClientMessage(playerid, Verde, "O veículo está sendo salvo, aguarde.");
 	return 1;
 }
 
 CMD:check(playerid, params[]) {
 	if(!IsPlayerAdmin(playerid)) return SendClientMessage(playerid, Vermelho, "Você não possui permissão para utilizar este comando.");
 	if(!GetPVarInt(playerid, "SaveCheck")) return SendClientMessage(playerid, Vermelho, "Você não está criando uma corrida.");
 
 	new Float: jPos[3];
 	GetPlayerPos(playerid, jPos[0], jPos[1], jPos[2]);
 
 	CheckPoint[playerid][GetPVarInt(playerid, "CPID")][0] = jPos[0];
 	CheckPoint[playerid][GetPVarInt(playerid, "CPID")][1] = jPos[1];
 	CheckPoint[playerid][GetPVarInt(playerid, "CPID")][2] = jPos[2];
 
 	new msg[85];
 	format(msg, sizeof(msg), "-> CP %d salvo com sucesso, você pode finalizar a corrida usando '/finalizar'.", GetPVarInt(playerid, "CPID"));
 	SendClientMessage(playerid, Verde, msg);
 	SetPVarInt(playerid, "CPID", GetPVarInt(playerid, "CPID") + 1);
 	return 1;
 }
 
 CMD:finalizar(playerid, params[])
 {
 	if(!IsPlayerAdmin(playerid)) return SendClientMessage(playerid, Vermelho, "Você não possui permissão para utilizar este comando.");
 
 	new Arq[90];
 	if(GetPVarInt(playerid, "SaveVeiculo"))
 	{
 		format(Arq, sizeof(Arq), PASTA_Corrida, GetPVarInt(playerid, "CorridaID"));
 
 		new line[200], name[90];
 		for(new V; V < GetPVarInt(playerid, "VID"); V++)
 		{
 			format(line, sizeof(line), "%d, %f, %f, %f, %f", CarrosInfos[V][VehID], CarrosInfos[V][CoordX], CarrosInfos[V][CoordY], CarrosInfos[V][CoordZ], CarrosInfos[V][Angulo]);
 			format(name, sizeof(name), "Veiculo%d", V);
 			DOF2_SetString(Arq, name, line);
 			if(CarroCorrida[V] != INVALID_VEHICLE_ID)
 			{
 				DestroyVehicle(CarroCorrida[V]);
 				CarroCorrida[V] = INVALID_VEHICLE_ID;
 			}
 		}
 
 		DOF2_SetInt(Arq, "Vagas", GetPVarInt(playerid, "VID"));
 
 		DeletePVar(playerid, "SaveVeiculo");
 		DeletePVar(playerid, "VID");
 		SendClientMessage(playerid, Verde, "-> Veículos salvos com sucesso, agora salve os CP's.");
 		SendClientMessage(playerid, Verde, "-> Vá até a largada e use '/check'.");
 		SetPVarInt(playerid, "SaveCheck", 1);
 		return 1;
 	}
 	if(GetPVarInt(playerid, "SaveCheck")) {
 		format(Arq, sizeof(Arq), PASTA_Corrida, GetPVarInt(playerid, "CorridaID"));
 
 		new line[200], name[90];
 		for(new C; C < GetPVarInt(playerid, "CPID"); C ++)
 		{
 			format(line, sizeof(line), "%f, %f, %f", CheckPoint[playerid][C][0], CheckPoint[playerid][C][1], CheckPoint[playerid][C][2]);
 			format(name, sizeof(name), "CheckPoint%d", C);
 			DOF2_SetString(Arq, name, line);
 		}
 
 		DOF2_SetInt(Arq, "TotalCPs", GetPVarInt(playerid, "CPID"));
 		DOF2_SetInt(Arq, "Interior", GetPlayerInterior(playerid));
 
 		ResetPlayerCorrida(playerid);
 		SendClientMessage(playerid, Verde, "-> Corrida criada com sucesso, basta carrega-lo no menu do comando '/criarcorrida'.");
 		return 1;
 	}
 	return 1;
 }
 
 PlayerClosetEvent(playerid) {
 	if(E_Enum[CorridaAtivo] == false) return SendClientMessage(playerid, Vermelho, "~ Não há corrida ativa no momento.");
 	ResetAllCorrida(0);
 	DisableRemoteVehicleCollisions(playerid, 0);
 
 	new msg[128];
 	if(playerid != GetMaxPlayers()+1) format(msg, sizeof(msg), "{5A9BC6}[!] O(A) Administrador(a) %s fechou a corrida.", GetPlayerNameEx(playerid));
 	else format(msg, sizeof(msg), "-> O Admin Bot fechou a corrida.");
 	SendClientMessageToAll(Amarelo, msg);
 	return 0;
 }
 
 ResetAllCorrida(opcao) {
 
 	E_Enum[PosCorrida][0] = 0.0;
 	E_Enum[PosCorrida][1] = 0.0;
 	E_Enum[PosCorrida][2] = 0.0;
 
 	for(new V; V < MAX_PLAYERS; V++) {
 		VeiculoCoord[V][0] = 0.0;
 		VeiculoCoord[V][1] = 0.0;
 		VeiculoCoord[V][2] = 0.0;
 		VeiculoCoord[V][3] = 0.0;
 		VeiculoModel[V] = 0;
 	}
 
 	for(new C; C < E_Enum[TotalCP]; C++) {
 		CPCoord[C][0] = 0.0;
 		CPCoord[C][1] = 0.0;
 		CPCoord[C][2] = 0.0;
 	}
 
 	GangZoneDestroy(E_Enum[GangZoneCorrida]);
 
 	E_Enum[CorridaAtivo] = false;
 	format(E_Enum[NomeCorrida], 30, "N/D");
 	E_Enum[VagasCorrida] = 0;
 	E_Enum[PlayersCorrida] = 0;
 	for(new v; v < 50; v++) E_Enum[VagasOcupadas][v] = false;
 
 	for(new t; t < 3; t++) TextDrawHideForAll(E_Enum[TextDrawsCorrida][t]);
 	E_Enum[Int_Corrida] = 0;
 	E_Enum[Virtual_World] = 0;
 	E_Enum[CorridaCongelado] = false;
 	E_Enum[CorridaVida] = 100;
 	E_Enum[Corridakev] = 0;
 	E_Enum[TotalCP] = 0;
 	E_Enum[IsRace] = false;
 	E_Enum[CorridaIniciado] = false;
 	E_Enum[CorridaTrancado] = false;
 	E_Enum[CPStyle] = 0;
 	format(E_Enum[Organizador], 24, "Ninguem");
  	if(!opcao) E_Enum[Tempo] = gettime();
 	KillTimer(E_Enum[InicioRandomico]);
 
 	foreach(Player, i) {
 		if(GetPVarInt(i, "NoCorrida")) {
 			DestroyVehicle(VeiculoCorrida[i]);
 			VeiculoCorrida[i] = INVALID_VEHICLE_ID;
 			SpawnPlayer(i);
 			DisablePlayerRaceCheckpoint(i);
 			RemovePlayerMapIcon(i, 20);
 			SetPlayerVirtualWorld(i, 0);
 		}
 		DeletePVar(i, "NoCorrida");
 		DeletePVar(i, "ExpulsoCorrida");
 		DeletePVar(i, "ProximoCP");
 		DeletePVar(i, "VagaID");
 	}
 	return 0;
 }
 
 PlayerCancelEvent(playerid) {
 	if(E_Enum[CorridaAtivo] == false) return SendClientMessage(playerid, Vermelho, "~ Não há Corrida corrida ativa no momento.");
 	ResetAllCorrida(1);
 	DisableRemoteVehicleCollisions(playerid, 0);
 
 	new msg[128];
 	if(playerid != GetMaxPlayers()+1) format(msg, sizeof(msg), "{5A9BC6}[!] O(A) Administrador(a) %s cancelou a corrida.", GetPlayerNameEx(playerid));
 	else format(msg, sizeof(msg), "{5A9BC6}[!] O Admin Bot cancelou a corrida.");
 	SendClientMessageToAll(Verde, msg);
 
 	return 0;
 }
 
 
 IsOrganizador(playerid) {
 	if(IsPlayerAdmin(playerid)) return 0;
 	new Msg;
 	if(strcmp(GetPlayerNameEx(playerid), E_Enum[Organizador])) Msg = SendClientMessage(playerid, Vermelho, "~ Você não é o organizador(a) do Corrida!");
 	return Msg;
 }
 
 GetNextEvent() {
 	new Arq[90];
 	for(new e; e < MAX_CorridaS; e ++) {
 		format(Arq, sizeof(Arq), PASTA_Corrida, e);
 		if(!DOF2_FileExists(Arq)) return e;
 	}
 	return -1;
 }
 
 
 CMD:comecarcorrida(playerid, params[])
 {
 	if(!IsPlayerAdmin(playerid)) return SendClientMessage(playerid, Vermelho, "Você não possui permissão para utilizar este comando.");
 	if(E_Enum[CorridaAtivo] == false) return SendClientMessage(playerid, Vermelho, "Não há nenhum Corrida no momento.");
 	if(E_Enum[CorridaIniciado] == true) return SendClientMessage(playerid, Vermelho, "Corrida já foi iniciado.");
 	if(IsOrganizador(playerid)) return 1;
 
 	foreach(Player, i) {
 		if(GetPVarInt(i, "NoCorrida")) CreatePlayerCountdown(i, 5, 1);
 	}
 
 	SetTimer("IniciarCorrida", 6000, false);
 
 	new msg[60];
 	format(msg, sizeof(msg), "-> O(a) Administrador(a) %s iniciou a corrida.", GetPlayerNameEx(playerid));
 	SendClientMessageToAll(Azul, msg);
 	return 1;
 }
 
 public OnPlayerSpawn(playerid) {
 	ResetPlayerCorrida(playerid);
 	return 1;
 }
 
 ResetPlayerCorrida(playerid) {
 	if(!IsPlayerConnected(playerid)) return 1;
 	if(GetPVarInt(playerid, "NoCorrida") && E_Enum[CorridaAtivo] == true) {
 		E_Enum[PlayersCorrida] -= 1;
 		E_Enum[VagasOcupadas][GetPVarInt(playerid, "VagaID")] = false;
 		new Td[60];
 		format(Td, sizeof(Td), "Vagas: %d/%d", E_Enum[PlayersCorrida], E_Enum[VagasCorrida]);
 		TextDrawSetString(E_Enum[TextDrawsCorrida][2], Td);
 		if(E_Enum[PlayersCorrida] == 0 && E_Enum[CorridaIniciado] == true) {
 			SendClientMessageToAll(LARANJA, "{5A9BC6}[!] O Admin Bot fechou a corrida por falta de participantes.");
 			ResetAllCorrida(0);
 		}
 	}
 
 	DestroyVehicle(VeiculoCorrida[playerid]);
 	VeiculoCorrida[playerid] = INVALID_VEHICLE_ID;
 
 	DeletePVar(playerid, "VagaID");
 	DeletePVar(playerid, "CorridaID");
 	DeletePVar(playerid, "SaveVeiculo");
 	DeletePVar(playerid, "ExpulsoCorrida");
 	DeletePVar(playerid, "CPID");
 	DeletePVar(playerid, "SaveCheck");
 	DeletePVar(playerid, "NoCorrida");
 	DeletePVar(playerid, "VID");
 	DeletePVar(playerid, "ProximoCP");
 	DisablePlayerRaceCheckpoint(playerid);
 	SetPlayerVirtualWorld(playerid, 0);
 	SetPlayerInterior(playerid, 0);
 
     if(GetPVarInt(playerid, "CriandoCorridaPersonalizado") == 1)
     {
         DeletePVar(playerid, "CriandoCorridaPersonalizado");
 		for(new c; c < MAX_CPS; c++) {
 			if(c < MAX_PLAYERS)
 			{
 				CarrosInfos[c][CoordX] = 0.0, CarrosInfos[c][CoordY] = 0.0, CarrosInfos[c][CoordZ] = 0.0, CarrosInfos[c][Angulo] = 0.0;
 				CarrosInfos[c][VehID] = 0, DestroyVehicle(CarroCorrida[c]), CarroCorrida[c] = INVALID_VEHICLE_ID;
 			}
 			CheckPoint[playerid][c][0] = 0.0, CheckPoint[playerid][c][1] = 0.0, CheckPoint[playerid][c][2] = 0.0;
 		}
 	}
 	return 0;
 }
 
 public OnPlayerDisconnect(playerid, reason) {
 	if(GetPVarInt(playerid, "CriandoCorridaPersonalizado")) DeletarCorrida(GetPVarInt(playerid, "CorridaID"));
 	else if(GetPVarInt(playerid, "NoCorrida")) ResetPlayerCorrida(playerid);
 
 	if(noCorrida[playerid] == 1)
 	{
 		if(Proibido == 0)
 		{
 			PlayersNaCorrida--;
 			noCorrida[playerid] = 0;
 			format(StringEV, 128, "{4682B4}! Desocupou-se uma vaga no Corrida! Corra! Use: {FFFFFF}/irCorrida.", PlayersNaCorrida, VagasNaCorrida);
 			SendClientMessageToAll(-1, StringEV);
 		}
 	}
 	return 1;
 }
 
 public OnDialogResponse(playerid, dialogid, response, listitem, inputtext[]) {
     // Sistema de Corrida
 	if(dialogid == DIALOG_CRIAR_Corrida && response == 1)
 	{
 		if(listitem == 0)
 		{
 		    if(!IsPlayerAdmin(playerid)) return SendClientMessage(playerid, Vermelho, "-> Você precisa está na rcon para criar corrida.");
 			ShowPlayerDialog(playerid, DIALOG_Corrida_PERSONALIZADO, DIALOG_STYLE_LIST, "Corrida", "Criar Corrida", "Selecionar", "Voltar");
 		}
 		if(listitem == 1) {
 			if(gettime() - E_Enum[Tempo] < 600) return SendClientMessage(playerid, Amarelo, "-> Aguarde algum tempo para criar outra corrida.");
 			new str[5000], d[180], cont, Arq[90];
 			for(new e; e < MAX_CorridaS; e ++) {
 				format(Arq, sizeof(Arq), PASTA_Corrida, e);
 				if(!DOF2_FileExists(Arq)) continue;
 				format(d, sizeof(d), "Nome: %s - Vagas: %d - Tipo: %s - Criador(a): %s\n", DOF2_GetString(Arq, "Nome"), DOF2_GetInt(Arq, "Vagas"), DOF2_GetString(Arq, "Tipo"), DOF2_GetString(Arq, "Criador"));
 				strcat(str, d, sizeof(str));
 				ListaCorrida[playerid][cont] = e;
 				cont++;
 			}
 			if(!cont) return SendClientMessage(playerid, Vermelho, "-> Não tem nenhuma corrida disponivel.");
 			else ShowPlayerDialog(playerid, DIALOG_CARREGAR_Corrida, DIALOG_STYLE_LIST, "{FFFFFF}Corrida", str, "Carregar", "Voltar");
 			return 1;
 		}
 	}
 
 	if(dialogid == DIALOG_CARREGAR_Corrida) {
 		if(!response) return ShowPlayerDialog(playerid, DIALOG_CRIAR_Corrida, DIALOG_STYLE_LIST, "Criar Corrida", "Criar Corrida\nCarregar Corrida", "Selecionar", "Voltar");
 		if(listitem >= 0) return CarregarCorrida(playerid, ListaCorrida[playerid][listitem]);
 	}
 
 	if(dialogid == DIALOG_Corrida_PERSONALIZADO) {
 		if(!response) return ShowPlayerDialog(playerid, DIALOG_CRIAR_Corrida, DIALOG_STYLE_LIST, "Criar Corrida", "Criar Corrida\nCarregar Corrida", "Selecionar", "Voltar");
 		if(listitem == 0) ShowPlayerDialog(playerid, DIALOG_NOME_CORRIDA, DIALOG_STYLE_INPUT, "Corrida", "Digite um nome para a corrida:\n", "Continuar", "Voltar");
 	}
 
 	if(dialogid == DIALOG_NOME_CORRIDA) {
 		if(!response) return ShowPlayerDialog(playerid, DIALOG_Corrida_PERSONALIZADO, DIALOG_STYLE_LIST, "Corrida", "Criar Corrida", "Selecionar", "Voltar");
 		if(!strlen(inputtext)) {
 			SendClientMessage(playerid, Vermelho, "-> Insira um nome para a corrida.");
 			ShowPlayerDialog(playerid, DIALOG_NOME_CORRIDA, DIALOG_STYLE_INPUT, "Corrida", "Digite um nome para a corrida:\n", "Continuar", "Voltar");
 			return 1;
 		}
 		new Arq[90];
 		for(new e; e < MAX_CorridaS; e++) {
 			format(Arq, sizeof(Arq), PASTA_Corrida, e);
 			if(!DOF2_FileExists(Arq)) continue;
 			if(strcmp(DOF2_GetString(Arq, "Nome"), inputtext)) continue;
 			SendClientMessage(playerid, Vermelho, "-> Uma corrida já está com esse nome.");
 			ShowPlayerDialog(playerid, DIALOG_NOME_CORRIDA, DIALOG_STYLE_INPUT, "Corrida", "Digite um nome para a corrida:\n", "Continuar", "Voltar");
 			return 1;
 		}
 		SetPVarInt(playerid, "CorridaID", GetNextEvent());
 		SetPVarInt(playerid, "CriandoCorridaPersonalizado", 1);
 		format(Arq, sizeof(Arq), PASTA_Corrida, GetPVarInt(playerid, "CorridaID"));
 		DOF2_CreateFile(Arq);
 		DOF2_SetString(Arq, "Nome", inputtext);
 		DOF2_SetString(Arq, "Tipo", "Race");
 		DOF2_SetString(Arq, "Criador", GetPlayerNameEx(playerid));
 		SetPVarInt(playerid, "SaveVeiculo", 1);
 		ShowPlayerDialog(playerid, DIALOG_DEFINIR_CHECK, DIALOG_STYLE_INPUT, "{FFFFFF}Estilo CP", "{FFFFFF}Digite o ID do checkpoint que deseja:\n\n{FF0000}Ultilize Apenas os ID's:\nID: 3 - CheckAéreo\nID: 0 - CheckCorrida", "Definir", "");
 		SendClientMessage(playerid, Vermelho, "~ Vá até a posição do veículo e use '/veiculo'.");
 		return 1;
 	}
 
 	if(dialogid == DIALOG_DEFINIR_CHECK) {
 	    if(!response) return ShowPlayerDialog(playerid, DIALOG_DEFINIR_CHECK, DIALOG_STYLE_LIST, "Estilo CP", "Digite o id do checkpoint que deseja:\n", "Definir", "");
 	    if(!IsNumeric(inputtext)) return SendClientMessage(playerid, Vermelho, "-> Valor não disponivel"), ShowPlayerDialog(playerid, DIALOG_DEFINIR_CHECK, DIALOG_STYLE_LIST, "Estilo CP", "Digite o id do checkpoint que deseja:\n", "Definir", ""), 1;
 	    if(!strlen(inputtext)) return ShowPlayerDialog(playerid, DIALOG_DEFINIR_CHECK, DIALOG_STYLE_LIST, "Estilo CP", "Digite o id do checkpoint que deseja:\n", "Definir", "");
 	    if(strval(inputtext) > 3) return SendClientMessage(playerid, Vermelho, "-> Valores Permitidos: 0-3"), ShowPlayerDialog(playerid, DIALOG_DEFINIR_CHECK, DIALOG_STYLE_LIST, "Estilo CP", "Digite o id do checkpoint que deseja:\n", "Definir", ""), 1;
 		new Arq[90];
 		format(Arq, sizeof(Arq), PASTA_Corrida, GetPVarInt(playerid, "CorridaID"));
 		if(!DOF2_FileExists(Arq)) return 1;
 		DOF2_SetInt(Arq, "CheckStyle", strval(inputtext));
 		SendClientMessage(playerid, Verde, "-> CheckPoint salvo com sucesso.");
 		return 1;
 	}
 	return 1;
 }
 
 stock PlayerCreateEvent(playerid, vagas, const nome[], Float:eX, Float:eY, Float:eZ, eI)
 {
 	if(CorridaCriado == 1)
 	{
 		SendClientMessage(playerid, Vermelho, "Um Corrida já foi criado, espere terminar para criar outro.");
 		return 1;
 	}
 	if(Proibido == 1)
 	{
 		Proibido = 0;
 	}
 	CorridaTextDraw = 1;
 	CorridaCriado = 1;
 	VagasNaCorrida = vagas;
 
 	cX = eX,
 	cY = eY,
 	cZ = eZ,
 	interiorc = eI;
 
 	guerra = GangZoneCreate(eX-100, eY-100, eX+100, eY+100);
 	GangZoneShowForAll(guerra, Branco);
 
 	#if defined CorridaText
 	TextDrawShowForAll(Text_Corrida);
 	#endif
 
 	timer = SetTimerEx("Nupdate", 900, 1, "d", playerid);
 	GameTextForAll("~y~Corrida ~g~Criado", 6000, 1);
 
 	format(StringEV, sizeof(StringEV), "{FFFFFF} ~ {4682B4}O(A) Administrador(a) {FFFFFF}%s{4682B4} criou um Corrida. Nome: {FFFFFF}%s{4682B4} Vagas: {FFFFFF}%d.", GetPlayerNameEx(playerid), nome, vagas);
 	SendClientMessageToAll(Amarelo, StringEV);
 
 	SendClientMessage(playerid, 0x008000AA, "Corrida criado com sucesso use: /comecarCorrida quando você for inicia-lo.");
 	SendClientMessage(playerid, 0x008000AA, "Caso você queira cancela-lo use: /cancelarCorrida");
 	return 1;
 }
 
 stock GetPlayerNameEx(playerid) {
 	static Name[MAX_PLAYER_NAME];
 	GetPlayerName(playerid, Name, MAX_PLAYER_NAME);
 	return Name;
 }
 
 stock CreatePlayerCountdown(playerid, time, sound) {
 	if(IsPlayerCountdownStarted[playerid] == 0 && IsCountdownStarted == 0) {
 		PlayerCountdownTimer[playerid] = SetTimerEx("PlayerCountdown", 1000, 1, "id", playerid, sound);
 		PlayerCountdownCount[playerid] = time;
 		IsPlayerCountdownStarted[playerid] = 1;
 	}
 }
 
 stock SetPlayerEventPos(playerid) {
 	if(E_Enum[PlayersCorrida] == E_Enum[VagasCorrida]) return SendClientMessage(playerid, Vermelho, "~ Não há mais vagas nesta corrida.");
 	SetPVarInt(playerid, "NoCorrida", 1);
 	E_Enum[PlayersCorrida] += 1;
 	ResetPlayerWeapons(playerid);
 	SetPlayerColor(playerid, 0x000000FF);
 	SetPlayerVirtualWorld(playerid, E_Enum[Virtual_World]);
 	SetPlayerInterior(playerid, E_Enum[Int_Corrida]);
 
 	if(E_Enum[CorridaCongelado] == true || E_Enum[IsRace] == true) TogglePlayerControllable(playerid, false);
 	if(E_Enum[Corridakev] != 0) SetPlayerHealth(playerid, E_Enum[CorridaVida]);
 	else SetPlayerHealth(playerid, 100);
 
 	if(E_Enum[Corridakev] != 0) SetPlayerArmour(playerid, E_Enum[Corridakev]);
 	else SetPlayerArmour(playerid, 0);
 
 	if(E_Enum[IsRace] == true) SetarVeiculoCorrida(playerid);
 	else SetPlayerPos(playerid, E_Enum[PosCorrida][0], E_Enum[PosCorrida][1], E_Enum[PosCorrida][2]);
 
 	SendClientMessage(playerid, LARANJA, "{5A9BC6}[!] Você entrou na corrida, aguarde ela começar.");
 	DisableRemoteVehicleCollisions(playerid, 1);
 
 	format(StringEV, sizeof(StringEV), "{4682B4}| {FFFFFF}CORRIDA {4682B4}| {FFFFFF}%s foi para uma corrida, use: {4682B4}/ircorrida.", GetPlayerNameEx(playerid));
 	SendClientMessageToAll(-1, StringEV);
 
 	new Td[60];
 	format(Td, sizeof(Td), "Vagas: %d/%d", E_Enum[PlayersCorrida], E_Enum[VagasCorrida]);
 	TextDrawSetString(E_Enum[TextDrawsCorrida][2], Td);
 
 	if(!strcmp(E_Enum[Organizador], "Ninguem")) SendClientMessage(playerid, LARANJA, "{5A9BC6}[!] Esta corrida foi criada pelo BOT do servidor, aguarde alguns segundos para começar.");
 	return 0;
 }
 
 stock DeletarCorrida(id) {
 	new Arq[90];
 	format(Arq, sizeof(Arq), PASTA_Corrida, id);
 	if(!DOF2_FileExists(Arq)) return printf("[SISTEMA] Erro ao deletar Corrida %d! Corrida inexistente.", id);
 
 	foreach(Player, i) {
 		if(!GetPVarInt(i, "CriandoCorridaPersonalizado") || GetPVarInt(i, "CorridaID") != id) continue;
 		ResetPlayerCorrida(i);
 	}
 
 	DOF2_RemoveFile(Arq);
 	return 1;
 }
 
 ContarCorridas() {
 	new Arq[90], cont;
 	for(new e; e < MAX_CorridaS; e++) {
 		format(Arq, sizeof(Arq), PASTA_Corrida, e);
 		if(DOF2_FileExists(Arq)) cont++;
 	}
 	return cont;
 }
 
 stock PlayerCloseEvent(playerid)
 {
 	if(CorridaCriado == 0)
 	{
 		SendClientMessage(playerid, Vermelho, "~ Não tem nenhum Corrida para fechar.");
 		return 1;
 	}
 	if(Proibido == 0)
 	{
 		Proibido = 1;
 	}
 	CorridaCriado = 0;
 	VagasNaCorrida = 0;
 	PlayersNaCorrida = 0;
 
 	foreach(Player, i)
 	{
 		noCorrida[i] = 0;
 		ExpulsoCorrida[i] = 0;
 	}
 
 	if(CorridaTextDraw == 1)
 	{
 		KillTimer(timer);
 
 		#if defined CorridaText
 		TextDrawHideForAll(Text_Corrida);
 		#endif
 
 		CorridaTextDraw = 0;
 	}
 
 	GangZoneHideForAll(guerra);
 	GangZoneDestroy(guerra);
 
 	GameTextForAll("~y~Corrida ~r~Fechado", 6000, 1);
 	format(StringEV, sizeof(StringEV), "O(a) Administrador %s fechou o Corrida.", GetPlayerNameEx(playerid));
 	SendClientMessageToAll(LARANJA, StringEV);
 	return 1;
 }
 
 public IsNumeric(const string[])
 {
 	for (new i = 0, j = strlen(string); i < j; i++) if(string[i] > '9' || string[i] < '0') return 0;
 	return 1;
 }
 
 stock PlayerExpulsePlayerEvent(playerid, plid, motivo[])
 {
 	if(CorridaCriado == 0)
 	{
 		SendClientMessage(playerid, Vermelho, "Não tem nenhum Corrida aberto.");
 		return 1;
 	}
 	if(!IsPlayerConnected(plid))
 	{
 		SendClientMessage(playerid, Vermelho, "Jogador não conectado.");
 		return 1;
 	}
 	if(noCorrida[plid] == 1)
 	{
 	    PlayersNaCorrida--;
 		ExpulsoCorrida[plid] = 1;
 		noCorrida[plid] = 0;
 		SpawnPlayer(plid);
 		format(StringEV, sizeof(StringEV), "{436EEE}O(a) jogador(a) {FFFFFF}%s {436EEE}foi expulso do Corrida. Motivo: {FFFFFF}%s", GetPlayerNameEx(plid), motivo);
 		SendClientMessageToAll(Amarelo, StringEV);
 	}
 	else
 	{
 		format(StringEV, sizeof(StringEV), "%s não está em um Corrida.", GetPlayerNameEx(plid));
 		SendClientMessage(playerid, Vermelho, StringEV);
 	}
 	return 1;
 }
 
 stock PlayerInitEvent(playerid)
 {
 	if(Proibido == 1)
 	{
 		SendClientMessage(playerid, Vermelho, "Corrida cancelado ou já começou.");
 		return 1;
 	}
 	if(CorridaCriado == 0)
 	{
 		SendClientMessage(playerid, Vermelho, "Não tem nenhum Corrida para começa-lo.");
 		return 1;
 	}
 	if(Proibido == 0)
 	{
 		Proibido = 1;
 	}
 	if(CorridaTextDraw == 1)
 	{
 		KillTimer(timer);
 
 		#if defined CorridaText
 		TextDrawHideForAll(Text_Corrida);
 		#endif
 
 		CorridaTextDraw = 0;
 	}
 
 	foreach(Player, i)
 	{
 		if(noCorrida[i] == 1)
 		{
 			CreatePlayerCountdown(i, 5, 1);
 			if(IsPlayerInAnyVehicle(i))
 			{
 				SetTimerEx("DestogglePlayerControllable", 6000, 0, "d", i);
 			}
 		}
 	}
 
 	GameTextForAll("~y~Corrida ~b~Iniciado", 6000, 1);
 	format(StringEV, sizeof(StringEV), "O(a) Administrador %s começou o Corrida.", GetPlayerNameEx(playerid));
 	SendClientMessageToAll(LARANJA, StringEV);
 
 	SendClientMessage(playerid, 0x008000AA, "O Corrida começou, quando terminar use: /fecharCorrida");
 	return 1;
 }
 
 
 forward DestogglePlayerControllable(playerid);
 public DestogglePlayerControllable(playerid) return TogglePlayerControllable(playerid, true);
 
 forward CriarVeiculoCorrida(playerid, id, Float: x, Float: y, Float: z, Float: a);
 public CriarVeiculoCorrida(playerid, id, Float: x, Float: y, Float: z, Float: a) {
 	CarroCorrida[GetPVarInt(playerid, "VID")] = CreateVehicle(id, x, y, z, a, -1, -1, -1);
 
 	new msg[50];
 	format(msg, sizeof(msg), "-> Veículo %d salvo com sucesso.", GetPVarInt(playerid, "VID"));
 	SendClientMessage(playerid, Verde, msg);
 	SendClientMessage(playerid, Verde, "-> Agora vá até a próxima posição e use: /veiculo para salvar os carros ou /finalizar para salvar os CP's.");
 	SetPVarInt(playerid, "VID", GetPVarInt(playerid, "VID") + 1);
 	return 0;
 }
 
 stock CarregarCorrida(playerid, Corridaid) {
 	if(E_Enum[CorridaAtivo] == true) return SendClientMessage(playerid, Vermelho, "-> Uma corrida está em andamento.");
 
 	new Arq[90];
 	format(Arq, sizeof(Arq), PASTA_Corrida, Corridaid);
 
 	E_Enum[VagasCorrida] = DOF2_GetInt(Arq, "Vagas");
 	E_Enum[Int_Corrida] = DOF2_GetInt(Arq, "Interior");
 	E_Enum[Virtual_World] = VIRTUAL_WORLD;
 	E_Enum[CorridaAtivo] = true;
 	if(!strcmp(DOF2_GetString(Arq, "Tipo"), "Race")) {
 		CarregarCheckPoints(Corridaid);
 		E_Enum[TotalCP] = DOF2_GetInt(Arq, "TotalCPs");
 		E_Enum[IsRace] = true;
 		E_Enum[CPStyle] = DOF2_GetInt(Arq, "CheckStyle");
 	}
 
 	if(playerid != INVALID_PLAYER_ID) format(E_Enum[Organizador], MAX_PLAYER_NAME, GetPlayerNameEx(playerid));
 	else format(E_Enum[Organizador], MAX_PLAYER_NAME, "Ninguem");
 	format(E_Enum[NomeCorrida], 30, DOF2_GetString(Arq, "Nome"));
 
 	if(!strcmp(E_Enum[Organizador], "Ninguem")) format(StringEV, sizeof(StringEV), "{FF4500}O(A) Administrador(a) Bot criou uma corrida. Nome: %s Vagas: %d.", DOF2_GetString(Arq, "Nome"), DOF2_GetInt(Arq, "Vagas"), DOF2_GetString(Arq, "Tipo"), DOF2_GetString(Arq, "Criador"));
 	else format(StringEV, sizeof(StringEV), "{FF4500}O(A) Administrador(a) %s criou uma corrida. Nome: %s Vagas: %d.", GetPlayerNameEx(playerid), DOF2_GetString(Arq, "Nome"), DOF2_GetInt(Arq, "Vagas"), DOF2_GetString(Arq, "Tipo"), DOF2_GetString(Arq, "Criador"));
 	SendClientMessageToAll(-1, StringEV);
 
 	for(new L; L < 3; L++) TextDrawShowForAll(E_Enum[TextDrawsCorrida][L]);
 
 	new Td[60];
 	format(Td, sizeof(Td), "Vagas: 0/%d - %s", E_Enum[VagasCorrida], DOF2_GetString(Arq, "Nome"));
 	TextDrawSetString(E_Enum[TextDrawsCorrida][2], Td);
 
 	ShowPlayerDialog(playerid, DIALOG_VIRTUAL_WORLD_Corrida, DIALOG_STYLE_MSGBOX, "{437FA7}Corrida", "{FFFFFF}Você deseja ir para o local da corrida?", "Sim", "Nao");
 	return 1;
 }
 
 stock CarregarCheckPoints(eid) {
 	new Arq[90], line[90], Float: CPs[3], Float: Veh[4], model;
 	format(Arq, sizeof(Arq), PASTA_Corrida, eid);
 
 	for(new C; C < DOF2_GetInt(Arq, "TotalCPs"); C++) {
 		format(line, sizeof(line), "CheckPoint%d", C);
 		if(!sscanf(DOF2_GetString(Arq, line), "p<,>fff", CPs[0], CPs[1], CPs[2])) {
 			CPCoord[C][0] = CPs[0];
 			CPCoord[C][1] = CPs[1];
 			CPCoord[C][2] = CPs[2];
 		}
 	}
 
 	for(new V; V < DOF2_GetInt(Arq, "Vagas"); V++) {
 		format(line, sizeof(line), "Veiculo%d", V);
 		if(!sscanf(DOF2_GetString(Arq, line), "p<,>dffff", model, Veh[0], Veh[1], Veh[2], Veh[3])) {
 			VeiculoCoord[V][0] = Veh[0];
 			VeiculoCoord[V][1] = Veh[1];
 			VeiculoCoord[V][2] = Veh[2];
 			VeiculoCoord[V][3] = Veh[3];
 			VeiculoModel[V] = model;
 		}
 	}
 
 	E_Enum[PosCorrida][0] = Veh[0], E_Enum[PosCorrida][1] = Veh[1], E_Enum[PosCorrida][2] = Veh[2];
 	return 1;
 }
 
 stock SetarVeiculoCorrida(playerid) {
 	for(new V; V < E_Enum[VagasCorrida]; V++) {
 		if(E_Enum[VagasOcupadas][V] == true) continue;
 		if(VeiculoCorrida[playerid] != INVALID_VEHICLE_ID) DestroyVehicle(VeiculoCorrida[playerid]);
 		if(IsPlayerInAnyVehicle(playerid)) SetVehicleToRespawn(GetPlayerVehicleID(playerid));
 		E_Enum[VagasOcupadas][V] = true;
 		SetPVarInt(playerid, "VagaID", V);
 		VeiculoCorrida[playerid] = AddStaticVehicleEx(VeiculoModel[V], VeiculoCoord[V][0], VeiculoCoord[V][1], VeiculoCoord[V][2], VeiculoCoord[V][3], -1, -1, false);
 		SetVehiclePos(VeiculoCorrida[playerid], VeiculoCoord[V][0], VeiculoCoord[V][1], VeiculoCoord[V][2]);
 		LinkVehicleToInterior(VeiculoCorrida[playerid], E_Enum[Int_Corrida]);
 		SetVehicleVirtualWorld(VeiculoCorrida[playerid], E_Enum[Virtual_World]);
 		PutPlayerInVehicle(playerid, VeiculoCorrida[playerid], 0);
 		return 1;
 	}
 	return 0;
 }
 
 forward IniciarCorrida();
 public IniciarCorrida() {
 	foreach(Player, i) {
 		if(!GetPVarInt(i, "NoCorrida")) continue;
 
 		if(E_Enum[CorridaVida] != 0) SetPlayerHealth(i, E_Enum[CorridaVida]);
 		else SetPlayerHealth(i, 100);
 
 		if(E_Enum[Corridakev] != 0) SetPlayerArmour(i, E_Enum[Corridakev]);
 		else SetPlayerArmour(i, 0);
 
 		E_Enum[Vencedores] = 0;
 
 		DeletePVar(i, "ProximoCP");
 		TogglePlayerControllable(i, true);
 		E_Enum[CorridaIniciado] = true;
 		DisablePlayerRaceCheckpoint(i);
 		if(E_Enum[IsRace] == true) SetPlayerRaceCheckpoint(i, E_Enum[CPStyle], CPCoord[0][0], CPCoord[0][1], CPCoord[0][2], CPCoord[1][0], CPCoord[1][1], CPCoord[1][2], 9.0);
 	}
 	KillTimer(E_Enum[TimerIniciar]);
 	KillTimer(E_Enum[InicioRandomico]);
 	E_Enum[InicioRandomico] = SetTimer("FecharCorrida", 800000, 0);
 	for(new L; L < 3; L++) TextDrawHideForAll(E_Enum[TextDrawsCorrida][L]);
 	return 0;
 }
 
 forward RandomEvent();
 public RandomEvent() {
 	KillTimer(E_Enum[TimerRandom]);
 
 	if(E_Enum[CorridaAtivo] == true) {
 		print("[SISTEMA] Corrida randômico não criado por haver outro Corrida em andamento!");
 		E_Enum[TimerRandom] = SetTimer("RandomEvent", 1800000, 0);
 		return 1;
 	}
 
 	if(Online < 5) {
 		print("[SISTEMA] Corrida randômico não criado por haver poucos jogadores online!");
 		E_Enum[TimerRandom] = SetTimer("RandomEvent", 1800000, 0);
 		return 1;
 	}
 
 	if(!ContarCorridas()) return E_Enum[TimerRandom] = SetTimer("RandomEvent", 3600000, 0);
 
 	new rand = random(ContarCorridas()), Arq[90];
 	format(Arq, sizeof(Arq), PASTA_Corrida, rand);
 	if(!DOF2_FileExists(Arq)) return RandomEvent();
 	CarregarCorrida(INVALID_PLAYER_ID, rand);
 
 	KillTimer(E_Enum[TimerIniciar]);
 	E_Enum[TimerIniciar] = SetTimer("IniciarCorridaRandomico", 40000, 0);
 	E_Enum[TimerRandom] = SetTimer("RandomEvent", 3600000, 0);
 	return 0;
 }
 
 public OnGameModeInit() {
     E_Enum[TimerRandom] = SetTimer("RandomEvent", 3600000, true);
 	return 1;
 }
 
 public OnPlayerEnterRaceCheckpoint(playerid)
 {
 	if(GetPVarInt(playerid, "NoCorrida"))
 	{
 		new id = GetPVarInt(playerid, "ProximoCP");
 		if(id < E_Enum[TotalCP])
 		{
 			SetPVarInt(playerid, "ProximoCP", id + 1);
 			id = GetPVarInt(playerid, "ProximoCP");
 			RemovePlayerMapIcon(playerid, 20);
 			DisablePlayerRaceCheckpoint(playerid);
 
 			if(id == E_Enum[TotalCP] - 1) {
 				if(E_Enum[CPStyle] != 3) SetPlayerRaceCheckpoint(playerid, 1, CPCoord[id][0], CPCoord[id][1], CPCoord[id][2], 0.0, 0.0, 0.0, 9.9);
 				else SetPlayerRaceCheckpoint(playerid, E_Enum[CPStyle], CPCoord[id][0], CPCoord[id][1], CPCoord[id][2], 0.0, 0.0, 0.0, 9.9);
 			}
 			else if(id <= E_Enum[TotalCP] - 2) {
 				SetPlayerRaceCheckpoint(playerid, E_Enum[CPStyle], CPCoord[id][0], CPCoord[id][1], CPCoord[id][2], CPCoord[id+1][0], CPCoord[id+1][1], CPCoord[id+1][2], 9.9);
 				SetPlayerMapIcon(playerid, 20, CPCoord[id+1][0], CPCoord[id+1][1], CPCoord[id+1][2], 53, -1);
 			}
 			new msg[50];
 			if(id != E_Enum[TotalCP])format(msg, sizeof(msg), "~r~CP: ~w~%d~y~/~w~%d", GetPVarInt(playerid, "ProximoCP"), E_Enum[TotalCP]);
 			else format(msg, sizeof(msg), "Corrida terminada!");
 			GameTextForPlayer(playerid, msg, 750, 1);
 			PlayerPlaySound(playerid, 1150,0.0,0.0,0.0);
 		}
 		if(id == E_Enum[TotalCP]) {
             new msg[128];
 			if(E_Enum[Vencedores] == 0)
 			{
 				format(msg, sizeof(msg), "%s[%d] venceu a corrida %s em primeiro lugar!", GetPlayerNameEx(playerid), playerid, E_Enum[NomeCorrida]);
 				SendClientMessageToAll(Azul, msg);
 				format(msg, sizeof(msg), "~y~~h~]] ~w~%s Venceu ~y~~h~]]", GetPlayerNameEx(playerid));
 				GameTextForAll(msg, 6000, 3);
 				SetPlayerScore(playerid, GetPlayerScore(playerid) + 5);
 				GivePlayerMoney(playerid, 25000);
 				SendClientMessage(playerid, Azul, "-> Você recebeu 5 leveis e R$25000 como prêmio.");
 			}
 			else if(E_Enum[Vencedores] == 1)
 			{
 				format(msg, sizeof(msg), "%s[%d] venceu a corrida %s em segundo lugar!", GetPlayerNameEx(playerid), playerid, E_Enum[NomeCorrida]);
 				SendClientMessageToAll(Amarelo, msg);
 				GivePlayerMoney(playerid, 50000);
 				SendClientMessage(playerid, Amarelo, "-> Você recebeu R$50 mil como prêmio.");
 			}
 			else if(E_Enum[Vencedores] == 2)
 			{
 				format(msg, sizeof(msg), "%s[%d] venceu a corrida %s em terceiro lugar!", GetPlayerNameEx(playerid), playerid, E_Enum[NomeCorrida]);
 				SendClientMessageToAll(Verde, msg);
 				GivePlayerMoney(playerid, 10000);
 				SendClientMessage(playerid, Verde, "-> Você recebeu 10 mil como prêmio.");
 
 				SendClientMessageToAll(Vermelho, "{5A9BC6}[!] O Admin Bot fechou a corrida.");
 				ResetAllCorrida(0);
 				KillTimer(E_Enum[InicioRandomico]);
 			}
 
 			E_Enum[Vencedores] ++;
 			DisablePlayerRaceCheckpoint(playerid);
 			DestroyVehicle(GetPlayerVehicleID(playerid));
 			SpawnPlayer(playerid);
 			return 1;
 		}
 	}
 	return 1;
 }
 
 stock SetPlayerEventPosCorrida(playerid)
 {
 	if(ExpulsoCorrida[playerid] == 1)
 	{
 		SendClientMessage(playerid, Vermelho, "Você foi expulso do Corrida.");
 		return 1;
 	}
 	if(noCorrida[playerid] == 1)
 	{
 		SendClientMessage(playerid, Vermelho, "Você já está no Corrida.");
 		return 1;
 	}
 	if(Proibido == 1)
 	{
 		SendClientMessage(playerid, Vermelho, "Corrida cancelado ou já começou.");
 		return 1;
 	}
 	if(CorridaCriado == 1)
 	{
 		if(PlayersNaCorrida == VagasNaCorrida)
 		{
 			SendClientMessage(playerid, Amarelo, "Acabaram-se as vagas no Corrida, tente no próximo.");
 		}
 		else
 		{
 			PlayersNaCorrida++;
 			noCorrida[playerid] = 1;
 			ResetPlayerWeapons(playerid);
 			SetPlayerInterior(playerid, interiorc);
 			SetPlayerPos(playerid, cX, cY, cZ);
 
 			TogglePlayerControllable(playerid, false);
 			SetTimerEx("DestogglePlayerControllable", 1000, 0, "d", playerid);
 
 			format(StringEV, sizeof(StringEV), "{4682B4} [ {FFFFFF}Corrida{4682B4} ] O(A) Jogador(a) %s foi para o Corrida. Vagas: {FFFFFF}%d/%d", GetPlayerNameEx(playerid), PlayersNaCorrida, VagasNaCorrida);
 			SendClientMessageToAll(Vermelho, StringEV);
 		}
 	}
 	return 1;
 }
 
 main(){printf("Init'");}
 
 stock SetPlayerEventExit(playerid)
 {
 	if(noCorrida[playerid] == 1)
 	{
 	    PlayersNaCorrida--;
 		noCorrida[playerid] = 0;
 		SpawnPlayer(playerid);
 		format(StringEV, sizeof(StringEV), "{4682B4}[ {FFFFFF}Corrida{4682B4} ] O(A) jogador(a) {FFFFFF}%s {4682B4}saiu do Corrida.", GetPlayerNameEx(playerid));
 		SendClientMessageToAll(Amarelo, StringEV);
 	}
 	else
 	{
 		SendClientMessage(playerid, Amarelo, "Você não está em um Corrida.");
 	}
 	return 1;
 }
 
 public RaceTextUpdate(playerid)
 {
 	#if defined CorridaText
 	static Number = 0;
 	if(Text_Corrida != Text:INVALID_TEXT_DRAW) TextDrawSetString(Text_Corrida, NewsLine[Number++]);
 	if(Number == sizeof(NewsLine)) Number = 0;
 	#endif
 	return 1;
 }