Vehicle Mapper

#include <a_samp>
#include <streamer>
#include <zcmd>
#include <sscanf2>
#include <foreach>

// EDIT THESE DEFINES TO WHATEVER SUITS YOU
#define     USE_SYNC                    true        		// respawns the vehicle after you hit the cancel/finish button so it syncs with the world, disable this if you're mapping on a hill and the vehicle accidentally drives down the hill.
#define     MAX_VEHICLES_PER_PLAYER    	(50)               // maximum amount of vehicles 1 player can spawn
#define     LABEL_COLOR                 0xFFFFFFFF 			// Vehicle's label color
#define     ALLOW_ENTER_VEHICLE         false        		// if you don't want other people to enter the vehicles you mapped, set this to false.
#define     RCON_ONLY                   true                // set this to true if you only want RCON admins to be able to use the carmapper

#define     DEFAULT_DIALOG              (2015)      		// edit this if your dialogids mess up
#define     DIALOG_SAVE_VEHICLES        (DEFAULT_DIALOG+1)
#define     DIALOG_LOAD_VEHICLES        (DEFAULT_DIALOG+2)
#define     DIALOG_EXPORT_VEHICLES      (DEFAULT_DIALOG+3)

// DON'T EDIT BEYOND THIS POINT
#define     DEFAULT_VEHICLE_OBJECT      (19300)

#define COLOR_ORANGE 0xFF8800FF
#define EMBED_WHITE "{FFFFFF}"

native IsValidVehicle(vehicleid);

enum E_VEHICLE_DATA
{
	E_VEHICLE_MODEL,
	E_VEHICLE_ID,
	E_VEHICLE_OBJECT,
	E_VEHICLE_INTERIOR,
	Text3D:E_VEHICLE_LABEL,
	Float: E_VEHICLE_X,
	Float: E_VEHICLE_Y,
	Float: E_VEHICLE_Z,
	Float: E_VEHICLE_ROT
};

new gVehicles[ MAX_PLAYERS ][ MAX_VEHICLES_PER_PLAYER ][ E_VEHICLE_DATA ];
new gCount[ MAX_PLAYERS char ] = { 0, 0, ... };
new bool: gMapping[ MAX_PLAYERS char ] = { false, false, ... };

new DB:db;

public OnFilterScriptInit()
{
	print("\n--------------------------------------");
	print("Car Mapper by Smileys Loaded!");
	print("--------------------------------------\n");

    if( ( db = db_open( "CarMapper/vehicles.db" ) ) == DB:0 )
	{
		print( "Failed to open a connection to \"CarMapper/vehicles.db\", please make sure you've created all the necessary directories inside the scriptfiles folder!" );
		SendRconCommand( "exit" );
	}
	else
	{
	    db_free_result( db_query( db, "CREATE TABLE IF NOT EXISTS Vehicles ( filename NOT NULL, model INTEGER NOT NULL, x_pos NOT NULL, y_pos NOT NULL, z_pos NOT NULL, z_rot NOT NULL );" ) );
	}
	return 1;
}

public OnFilterScriptExit()
{
	db_close( db );
	foreach( new playerid : Player)
	{
	    printf( "%i vehicles deleted!", RemoveAllVehicles( playerid ) );
	}
	return 1;
}

public OnDialogResponse( playerid, dialogid, response, listitem, inputtext[ ] )
{
	if( !gMapping{ playerid } ) return 1;
	switch( dialogid )
	{
	    case DIALOG_SAVE_VEHICLES:
	    {
	        if( !response ) return 1;
	        
	        if( !( 0 < strlen( inputtext ) < 32 ) )
				return ShowPlayerDialog( playerid, DIALOG_SAVE_VEHICLES, DIALOG_STYLE_INPUT, "-> Save Vehicles <-", "{FF0000}The filename must be between 0 and 32 characters!\n{FFFFFF}Please enter the filename you want the vehicles to save in.", "Save!", "Cancel" );
			
			new Query[ 32 ], DBResult: result, string[ 88 ];
			format( Query, sizeof( Query ), "SELECT * FROM Vehicles WHERE filename = '%s'", inputtext );
			result = db_query( db, Query );

			if( db_num_rows( result ) )
			{
			    db_free_result( result );
                return ShowPlayerDialog( playerid, DIALOG_SAVE_VEHICLES, DIALOG_STYLE_INPUT, "-> Save Vehicles <-", "{FF0000}This file already exists!\n{FFFFFF}Please enter the filename you want the vehicles to save in.", "Save!", "Cancel" );
			}
			
	        new query[ 256 ], counter = 0;
	        for( new i = 0; i < MAX_VEHICLES_PER_PLAYER; i++ )
	        {
	            if( IsValidVehicle( gVehicles[ playerid ][ i ][ E_VEHICLE_ID ] ) )
	            {
	        		format( query, sizeof( query ),
						"INSERT INTO Vehicles ( filename, model, x_pos, y_pos, z_pos, z_rot ) VALUES( '%s', %i, %f, %f, %f, %f );",
						inputtext, gVehicles[ playerid ][ i ][ E_VEHICLE_MODEL ], gVehicles[ playerid ][ i ][ E_VEHICLE_X ], gVehicles[ playerid ][ i ][ E_VEHICLE_Y ], gVehicles[ playerid ][ i ][ E_VEHICLE_Z ], gVehicles[ playerid ][ i ][ E_VEHICLE_ROT ]
					);
					
					db_free_result( db_query( db, query ) );
					++counter;
				}
			}
			format( string, sizeof( string ), "[CARMAPPER]"EMBED_WHITE" %i vehicles saved to \"%s\".", counter, inputtext );
			SendClientMessage( playerid, COLOR_ORANGE, string );
			return 1;
		}
	    case DIALOG_LOAD_VEHICLES:
	    {
	        if( !response ) return 1;
	        new query[ 64 ], DBResult:result, count = 0, string[ 88 ];
	        format( query, sizeof( query ), "SELECT * FROM Vehicles WHERE filename = '%s'", inputtext );
			result = db_query( db, query );
			
			if( db_num_rows( result ) > 0 )
			{
			    new field[ 16 ];
			    do
			    {
			        db_get_field_assoc( result, "model", field, sizeof( field ) );
			        gVehicles[ playerid ][ count ][ E_VEHICLE_MODEL ] = strval( field );
			        
                    db_get_field_assoc( result, "x_pos", field, sizeof( field ) );
			        gVehicles[ playerid ][ count ][ E_VEHICLE_X ] = floatstr( field );
			        
			        db_get_field_assoc( result, "y_pos", field, sizeof( field ) );
			        gVehicles[ playerid ][ count ][ E_VEHICLE_Y ] = floatstr( field );
			        
			        db_get_field_assoc( result, "z_pos", field, sizeof( field ) );
			        gVehicles[ playerid ][ count ][ E_VEHICLE_Z ] = floatstr( field );
			        
			        db_get_field_assoc( result, "z_rot", field, sizeof( field ) );
			        gVehicles[ playerid ][ count ][ E_VEHICLE_ROT ] = floatstr( field );
			        
			        SpawnVehicle( playerid, count, gVehicles[ playerid ][ count ][ E_VEHICLE_MODEL ], gVehicles[ playerid ][ count ][ E_VEHICLE_X ], gVehicles[ playerid ][ count ][ E_VEHICLE_Y ], gVehicles[ playerid ][ count ][ E_VEHICLE_Z ], gVehicles[ playerid ][ count ][ E_VEHICLE_ROT ] );
			        
			        count++;
			    }
			    while( db_next_row( result ) );
			}
			else
			    return ShowPlayerDialog( playerid, DIALOG_LOAD_VEHICLES, DIALOG_STYLE_INPUT, "-> Load Vehicles <-", "{FF0000}This file does not exist!\n{FFFFFF}Please enter the filename you want to load the vehicles from", "Load!", "Cancel" );

			db_free_result( result );
			
			format( string, sizeof( string ), "[CARMAPPER]"EMBED_WHITE" %i vehicles loaded from \"%s\".", count, inputtext );
			SendClientMessage( playerid, COLOR_ORANGE, string );
			gCount{ playerid } = count;
			return 1;
	    }
		default: // exporting a map
		{
		    if( !response ) return 1;
		    
		    if( !( 0 < strlen( inputtext ) < 32 ) )
				return ShowPlayerDialog( playerid, DIALOG_EXPORT_VEHICLES, DIALOG_STYLE_INPUT, "-> Export Vehicles <-", "{FF0000}The filename must be between 0 and 32 characters!\n{FFFFFF}Please enter the filename you want the vehicles to export to.", "Export!", "Cancel" );

		
		    new filename[ 88 ], counter = 0;
			format( filename, sizeof( filename ), "CarMapper/exports/%s.pwn", inputtext );

			if( !fexist( filename ) )
			{
			    new File:file = fopen( filename, io_write ), line[ 128 ];
			    fwrite( file, "new vehicle;\n\n" );
			    for( new i = 0; i < MAX_VEHICLES_PER_PLAYER; i++ )
			    {
			        if( IsValidVehicle( gVehicles[ playerid ][ i ][ E_VEHICLE_ID ] ) )
			        {
			            format( line, sizeof( line ), "vehicle = CreateVehicle( %i, %f, %f, %f, %f, -1, -1, -1 );\n", gVehicles[ playerid ][ i ][ E_VEHICLE_MODEL ], gVehicles[ playerid ][ i ][ E_VEHICLE_X ], gVehicles[ playerid ][ i ][ E_VEHICLE_Y ], gVehicles[ playerid ][ i ][ E_VEHICLE_Z ], gVehicles[ playerid ][ i ][ E_VEHICLE_ROT ] );
						fwrite( file, line );
						format( line, sizeof( line ), "LinkVehicleToInterior( vehicle, %i );\n", gVehicles[ playerid ][ i ][ E_VEHICLE_INTERIOR ] );
                        fwrite( file, line );
                        format( line, sizeof( line ), "SetVehicleVirtualWorld( vehicle, %i );\n\n", GetVehicleVirtualWorld( gVehicles[ playerid ][ i ][ E_VEHICLE_ID ] ) );
                        fwrite( file, line );
						++counter;
			        }
			    }
                fclose( file );
			}
			else return ShowPlayerDialog( playerid, DIALOG_EXPORT_VEHICLES, DIALOG_STYLE_INPUT, "-> Export Vehicles <-", "{FF0000}This file already exists!\n{FFFFFF}Please enter the filename you want to export the vehicles to.", "Export!", "Cancel" );
			
			format( filename, sizeof( filename ), "[CARMAPPER]"EMBED_WHITE" %i vehicles were exported to \"%s.pwn\".", counter, inputtext );
			SendClientMessage( playerid, COLOR_ORANGE, filename );
			return 1;
		}
	}
	return 1;
}

public OnPlayerEditDynamicObject( playerid, objectid, response, Float:x, Float:y, Float:z, Float:rx, Float:ry, Float:rz )
{
	for( new i = 0; i < MAX_VEHICLES_PER_PLAYER; i++ )
	{
	    if( objectid == gVehicles[ playerid ][ i ][ E_VEHICLE_OBJECT ] )
	    {
	        #if USE_SYNC == true
		        if( response < 2 ) // if finished
		        {
		            // re-creating the vehicle so it syncs correctly with the world
		            new world = GetPlayerVirtualWorld( playerid ), interior = GetPlayerInterior( playerid );
		            DestroyVehicle( gVehicles[ playerid ][ i ][ E_VEHICLE_ID ] );
					gVehicles[ playerid ][ i ][ E_VEHICLE_ID ] = CreateVehicle( gVehicles[ playerid ][ i ][ E_VEHICLE_MODEL ], x, y, z, rz, -1, -1, -1 );
					LinkVehicleToInterior( gVehicles[ playerid ][ i ][ E_VEHICLE_ID ], interior );
					SetVehicleVirtualWorld( gVehicles[ playerid ][ i ][ E_VEHICLE_ID ], world );
					return 1;
				}
			#endif
	        
			UpdateVehiclePosition( playerid, i, x, y, z, rz );
	        break;
	    }
	}
	return 1;
}

public OnPlayerDisconnect(playerid, reason)
{
	RemoveAllVehicles( playerid );
	gMapping{ playerid } = false;
	return 1;
}

public OnPlayerSpawn(playerid)
{
    CancelEdit( playerid );
	return 1;
}

public OnPlayerDeath(playerid, killerid, reason)
{
	CancelEdit( playerid );
	return 1;
}

public OnVehicleDeath(vehicleid, killerid)
{
	foreach( new playerid : Player)
	{
	    for( new i = 0; i < MAX_VEHICLES_PER_PLAYER; i++ )
	    {
	        if( vehicleid == gVehicles[ playerid ][ i ][ E_VEHICLE_ID ] )
			{
			    DeleteVehicle( playerid, i );
			    SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER] Warning: "EMBED_WHITE"One of your vehicles has been destroyed!" );
			    break;
			}
	    }
	}
	return 1;
}

public OnPlayerEnterVehicle(playerid, vehicleid, ispassenger)
{
	#if ALLOW_ENTER_VEHICLE == false
	foreach( new id : Player)
	{
	    for( new i = 0; i < MAX_VEHICLES_PER_PLAYER; i++ )
	    {
	        if( vehicleid == gVehicles[ id ][ i ][ E_VEHICLE_ID ] )
	        {
	            ClearAnimations( playerid );
				SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" You can't enter vehicles that were spawned by the carmapper!" );
				break;
			}
		}
	}
	#endif
	return 1;
}

public OnPlayerCommandText(playerid, cmdtext[])
{
	if (strcmp("/mycommand", cmdtext, true, 10) == 0)
	{
		// Do something here
		return 1;
	}
	return 0;
}



/* ---------> Custom Functions <----------- */

stock RemoveAllVehicles( playerid )
{
	new count = 0;
    for( new i = 0; i < MAX_VEHICLES_PER_PLAYER; i++ )
    {
		if( IsValidVehicle( gVehicles[ playerid ][ i ][ E_VEHICLE_ID ] ) )
		{
			DeleteVehicle( playerid, i );
			++count;
		}
    }
    gCount{ playerid } = 0;
	return count;
}

stock DeleteVehicle( playerid, slot )
{
	DestroyDynamicObject( gVehicles[ playerid ][ slot ][ E_VEHICLE_OBJECT ] );
	Delete3DTextLabel( gVehicles[ playerid ][ slot ][ E_VEHICLE_LABEL ] );
    DestroyVehicle( gVehicles[ playerid ][ slot ][ E_VEHICLE_ID ] );
    ResetSlot( playerid, slot );
    return 1;
}

stock ResetSlot( playerid, slot )
{
	gVehicles[ playerid ][ slot ][ E_VEHICLE_INTERIOR ] = -1;
	gVehicles[ playerid ][ slot ][ E_VEHICLE_MODEL ] = INVALID_VEHICLE_ID;
	gVehicles[ playerid ][ slot ][ E_VEHICLE_ID ] = INVALID_VEHICLE_ID;
	gVehicles[ playerid ][ slot ][ E_VEHICLE_OBJECT ] = INVALID_OBJECT_ID;
	UpdateVehiclePosition( playerid, slot, -1.0, -1.0, -1.0, -1.0 );
	return 1;
}

stock UpdateVehiclePosition( playerid, slot, Float:x, Float:y, Float:z, Float:rot )
{
    gVehicles[ playerid ][ slot ][ E_VEHICLE_X ] = x;
	gVehicles[ playerid ][ slot ][ E_VEHICLE_Y ] = y;
	gVehicles[ playerid ][ slot ][ E_VEHICLE_Z ] = z;
	gVehicles[ playerid ][ slot ][ E_VEHICLE_ROT ] = rot;

	SetVehiclePos( gVehicles[ playerid ][ slot ][ E_VEHICLE_ID ], x, y, z );
	SetVehicleZAngle( gVehicles[ playerid ][ slot ][ E_VEHICLE_ID ], rot );
	return 1;
}

stock getAvailableVehicleSlot( playerid )
{
	for( new i = 0; i < MAX_VEHICLES_PER_PLAYER; i++ )
	{
	    if( !IsValidVehicle( gVehicles[ playerid ][ i ][ E_VEHICLE_ID ] ) )
	    {
	    	return i;
		}
	}
	return -1;
}

stock SpawnVehicle( playerid, slot, modelid, Float:x, Float:y, Float:z, Float:rot )
{
	new label[ 32 ], world = GetPlayerVirtualWorld( playerid ), interior = GetPlayerInterior( playerid );

	// creating the vehicle
	gVehicles[ playerid ][ slot ][ E_VEHICLE_ID ] = CreateVehicle( modelid, x, y, z, rot, -1, -1, -1 );
	SetVehicleVirtualWorld( gVehicles[ playerid ][ slot ][ E_VEHICLE_ID ], world );
	LinkVehicleToInterior( gVehicles[ playerid ][ slot ][ E_VEHICLE_ID ], interior );

	gVehicles[ playerid ][ slot ][ E_VEHICLE_INTERIOR ] = interior;
	gVehicles[ playerid ][ slot ][ E_VEHICLE_MODEL ] = modelid;

	// attaching a label to it
	format( label, sizeof( label ), ":- Model: %i - ID: %i -:", modelid, slot );
	gVehicles[ playerid ][ slot ][ E_VEHICLE_LABEL ] = Create3DTextLabel( label, LABEL_COLOR, x, y, z, 40.0, world, 0 );
	Attach3DTextLabelToVehicle( gVehicles[ playerid ][ slot ][ E_VEHICLE_LABEL ], gVehicles[ playerid ][ slot ][ E_VEHICLE_ID ], 0.0, 0.0, 0.0 );

	// creating the object that's used to move the vehicle around
	gVehicles[ playerid ][ slot ][ E_VEHICLE_OBJECT ] = CreateDynamicObject( DEFAULT_VEHICLE_OBJECT, x, y, z, 0.0, 0.0, rot, world, interior, -1, 100.0, 100.0 );

	// updating it's position.
	UpdateVehiclePosition( playerid, slot, x, y, z, rot );

	// returning the vehicleID
	return gVehicles[ playerid ][ slot ][ E_VEHICLE_ID ];
}



/* ----------> COMMANDS <--------------- */

CMD:starteditor( playerid, params[ ] )
{
	#if RCON_ONLY == true
	if( !IsPlayerAdmin( playerid ) )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" Only RCON Admins can use the carmapper!" );
	#endif

 	if( !gMapping{ playerid } )
 	{
 	    gMapping{ playerid } = true;
		SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" Editor turned {00FF00}ON" );
	}
	else
	{
	    gMapping{ playerid } = false;
	    SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" Editor turned {FF0000}OFF" );
	}
	return 1;
}

CMD:cv( playerid, params[ ] )
	return cmd_createvehicle( playerid, params );

CMD:createvehicle( playerid, params[ ] )
{
    if( !gMapping{ playerid } )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" You're not in the editor yet, use /starteditor to begin!" );

	new iModel;
	if( sscanf( params, "i", iModel ) )
		return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" /createvehicle [modelid]" );

	if( !( 399 < iModel < 612 ) )
		return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" Invalid vehicle model!" );

	new slot = getAvailableVehicleSlot( playerid );

	if( getAvailableVehicleSlot( playerid ) < 0 )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" You can't create more than 100 vehicles!" );

    new
		Float:x,
		Float:y,
		Float:z,
		Float:angle
	;

    GetPlayerPos( playerid, x, y, z );
    GetPlayerFacingAngle( playerid, angle );
	SpawnVehicle( playerid, slot, iModel, x + 2.0, y + 2.0, z, angle );
	EditDynamicObject( playerid, gVehicles[ playerid ][ slot ][ E_VEHICLE_OBJECT ] );

	++gCount{ playerid };

	SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" Vehicle spawned, now move it to the desired location!" );
	return 1;
}

CMD:ev( playerid, params[ ] )
	return cmd_editvehicle( playerid, params );

CMD:editvehicle( playerid, params[ ] )
{
    if( !gMapping{ playerid } )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" You're not in the editor yet, use /starteditor to begin!" );

	new idx;
	if( sscanf( params, "i", idx ) )
		return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" /editvehicle [id]" );

	if( !( 0 <= idx < gCount{ playerid } ) || !IsValidVehicle( gVehicles[ playerid ][ idx ][ E_VEHICLE_ID ] ) )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" Invalid id specified." );

	EditDynamicObject( playerid, gVehicles[ playerid ][ idx ][ E_VEHICLE_OBJECT ] );

	new str[ 44 ];
	format( str, sizeof( str ), "[CARMAPPER]"EMBED_WHITE" Editing vehicle %i.", idx );
	SendClientMessage( playerid, COLOR_ORANGE, str );
	return 1;
}

CMD:dav( playerid, params[ ] )
	return cmd_deleteallvehicles( playerid, params );

CMD:deleteallvehicles( playerid, params[ ] )
{
    RemoveAllVehicles( playerid );
    SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" All vehicles have been destroyed!" );
    CancelEdit( playerid );
	return 1;
}

CMD:dv( playerid, params[ ] )
	return cmd_duplicatevehicle( playerid, params );

CMD:duplicatevehicle( playerid, params[ ] )
{
    if( !gMapping{ playerid } )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" You're not in the editor yet, use /starteditor to begin!" );

	new idx, Float:incr_x, Float:incr_y, Float:incr_z;
	if( sscanf( params, "ifff", idx, incr_x, incr_y, incr_z ) )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" /duplicatevehicle [id] [x offset] [y offset] [z offset]" );

	if( !( 0 <= idx < gCount{ playerid } ) || !IsValidVehicle( gVehicles[ playerid ][ idx ][ E_VEHICLE_ID ] ) )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" Invalid id specified." );

    new slot = getAvailableVehicleSlot( playerid );

	if( getAvailableVehicleSlot( playerid ) < 0 )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" You can't create more than 100 vehicles!" );

	new Float:x, Float:y, Float:z, Float:rot;
	GetVehiclePos( gVehicles[ playerid ][ idx ][ E_VEHICLE_ID ], x, y, z );
	GetVehicleZAngle( gVehicles[ playerid ][ idx ][ E_VEHICLE_ID ], rot );

    SpawnVehicle( playerid, slot, gVehicles[ playerid ][ idx ][ E_VEHICLE_MODEL ], x + incr_x, y + incr_y, z + incr_z, rot );
    printf( "%f, %f, %f - %f, %f, %f", x, y, z, x + incr_x, y + incr_y, z + incr_z );
	EditDynamicObject( playerid, gVehicles[ playerid ][ slot ][ E_VEHICLE_OBJECT ] );

	++gCount{ playerid };

	SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" Vehicle duplicated, please move it to the desired location!" );
	return 1;
}

CMD:delv( playerid, params[ ] )
	return cmd_deletevehicle( playerid, params );

CMD:deletevehicle( playerid, params[ ] )
{
    if( !gMapping{ playerid } )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" You're not in the editor yet, use /starteditor to begin!" );

	new idx;
	if( sscanf( params, "i", idx ) )
		return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" /deletevehicle [id]" );

	if( !( 0 <= idx < gCount{ playerid } ) || !IsValidVehicle( gVehicles[ playerid ][ idx ][ E_VEHICLE_ID ] ) )
		return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" Invalid id specified." );

	--gCount{ playerid };
	DeleteVehicle( playerid, idx );

	new str[ 44 ];
	format( str, sizeof( str ), "[CARMAPPER]"EMBED_WHITE" Vehicle %i deleted!", idx );
	SendClientMessage( playerid, COLOR_ORANGE, str );
	return 1;
}

CMD:sv( playerid, params[ ] )
	return cmd_savevehicles( playerid, params );

CMD:savevehicles( playerid, params[ ] )
{
	if( !gMapping{ playerid } )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" You're not in the editor yet, use /starteditor to begin!" );

	ShowPlayerDialog( playerid, DIALOG_SAVE_VEHICLES, DIALOG_STYLE_INPUT, "-> Save Vehicles <-", "Please enter the filename you want the vehicles to save in.", "Save!", "Cancel" );
	return 1;
}

CMD:lv( playerid, params[ ] )
	return cmd_loadvehicles( playerid, params );

CMD:cmhelp( playerid, params[ ] )
{
	SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE"--------------------------------> CarMapper by Smileys <--------------------------------" );
	SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" /starteditor - /createvehicle - /deletevehicle --> --- - /cv - /delv" );
	SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" /editvehicle - /duplicatevehicle - /deleteallvehicles --> /ev - /dv - /dav" );
	SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" /savevehicles - /loadvehicles - /exportvehicles --> /sv - /lv - /exv" );
	SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" Thanks for using my carmapper, motivates me to create more useful scripts :P" );
	return 1;
}

CMD:loadvehicles( playerid, params[ ] )
{
	if( !gMapping{ playerid } )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" You're not in the editor yet, use /starteditor to begin!" );

	ShowPlayerDialog( playerid, DIALOG_LOAD_VEHICLES, DIALOG_STYLE_INPUT, "-> Load Vehicles <-", "Please enter the filename you want to load the vehicles from", "Load!", "Cancel" );
	return 1;
}

CMD:exv( playerid, params[ ] )
	return cmd_exportvehicles( playerid, params );

CMD:exportvehicles( playerid, params[ ] )
{
    if( !gMapping{ playerid } )
	    return SendClientMessage( playerid, COLOR_ORANGE, "[CARMAPPER]"EMBED_WHITE" You're not in the editor yet, use /starteditor to begin!" );

	ShowPlayerDialog( playerid, DIALOG_EXPORT_VEHICLES, DIALOG_STYLE_INPUT, "-> Export Vehicles <-", "Please enter the filename you want to export the vehicles to.", "Export!", "Cancel" );
	return 1;
}