/*
	Uncles Blitzer Include - V.1.1.0
	
	Diese Include wurde von UncleSub erstellt. - © 2013
	
	Credits müssen erhalten bleiben! Ansonsten darf diese Include
	frei verwendet und auch bearbeitet werden! Weiterveröffentlichen nur mit
	meiner Erlaubnis!
	
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	Funktionen:

	native CreateBlitzer(Float:x, Float:y, Float:z, Float:rz, MaxSpeed);
	native DestroyBlitzer(blitzerid);
	native IsBlitzer(blitzerid);
	native IsBlitzerArea(area); -> area = ID der Area, beim betreten von der Area in der man geblitzt wird
	native IsPlayerInRangeOfBlitzer(playerid);
	native GetBlitzerID(playerid); -> Die Blitzer ID des nächsten Blitzers. Returns -1 wenn keiner in der Nähe ist.
	
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	Callbacks:
	forward OnPlayerBlitzed(playerid, blitzerid, speed, maxspeed);
	
	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	
	Andere Konfigarationen: Vor dem Includieren können durch folgende Defines Vorkonfigurationen getroffen werden.
	
	#define BLITZER_NO_SAVE -> Wenn aktiviert, wird die Speicher- und Ladefunktion der Blitzer ausgeschaltet.
	#define BLITZER_KMH_TOLERANZ -> Dem Blitzer kann eine Toleranzgrenze mitgegeben werden, ab wann er blitzen soll.
	#define BLITZER_USE_GETVEHICLESPEED -> Wenn aktiviert, muss im Script eine Funktion mit Namen: "GetVehicleSpeed(vehicleid)" vorhanden sein;
	    Mit diesem Define wird festgelegt, wie die km/h berechnet werden (Evtl Berechnung vom Tacho nehmen).
*/

#include <a_samp>

#if defined Uncles_Blitzer_included
	#endinput
#endif
#define Uncles_Blitzer_included

#if !defined CreateDynamicRectangle
	#error Du hast den Incognito Streamer nicht installiert!
#endif

#if !defined _ALS_
    forward public _ALS_();
    _ALS_()<_ALS_:unhooked>{}
    _ALS_()<_ALS_:hooked>{}
    _ALS_()<>{}
#endif

#define MAX_U_BLITZER 100

#if !defined BLITZER_KMH_TOLERANZ
	#define BLITZER_KMH_TOLERANZ 2
#endif

forward OnPlayerBlitzed(playerid, blitzerid, speed, maxspeed);

enum u_blitzerdata
{
	ubID,
	Float:ubX,
	Float:ubY,
	Float:ubZ,
	Float:ubAng,
	ubMaxSpeed,
	ubObject,
	ubGebiet,
	bool:ubErstellt
}
new uBlitzer[MAX_U_BLITZER][u_blitzerdata];
#if !defined BLITZER_NO_SAVE
new DB:BlitzerDB;
#endif

//////////////////////////////////////////////////////////////////////\Functions\//////////////////////////////////////////////////////////////////////////////

stock CreateBlitzer(Float:x, Float:y, Float:z, Float:rz, MaxSpeed)
{
	for(new i; i < MAX_U_BLITZER; i++)
	{
	    if(uBlitzer[i][ubErstellt] == false)
	    {
	        #if !defined BLITZER_NO_SAVE
	        new string[156];
	        format(string, sizeof(string), "INSERT INTO `Blitzer` (`bID`, `bX`, `bY`, `bZ`, `bRZ`, `bMaxSpeed`) VALUES ('%i', '%f', '%f', '%f', '%f', '%i')", i, x, y, z, rz, MaxSpeed);
	        db_free_result(db_query(BlitzerDB, string));
	        #endif
			uBlitzer[i][ubObject] = CreateDynamicObject(18880, x, y, z-1.2, 0.0, 0.0, rz);
			uBlitzer[i][ubGebiet] = CreateDynamicRectangle(x-10, y-10, x+10, y+10);
			uBlitzer[i][ubID] = i;
			uBlitzer[i][ubX] = x;
			uBlitzer[i][ubY] = y;
			uBlitzer[i][ubZ] = z;
			uBlitzer[i][ubAng] = rz;
			uBlitzer[i][ubMaxSpeed] = MaxSpeed;
			uBlitzer[i][ubErstellt] = true;
			return i;
	    }
	}
	return print(">>> [Uncles Blitzer] FEHLER: Beim erstellen vom Blitzer ist ein Fehler aufgetreten. <<<") & 0;
}

stock DestroyBlitzer(blitzerid)
{
	if(uBlitzer[blitzerid][ubErstellt] == true)
	{
	    #if !defined BLITZER_NO_SAVE
	    new string[128];
	    format(string, sizeof(string), "DELETE FROM `Blitzer` WHERE `bID`='%i'", uBlitzer[blitzerid][ubID]);
	    db_free_result(db_query(BlitzerDB, string));
	    #endif
	    DestroyDynamicObject(uBlitzer[blitzerid][ubObject]);
	    DestroyDynamicArea(uBlitzer[blitzerid][ubGebiet]);
	    uBlitzer[blitzerid][ubObject] = INVALID_OBJECT_ID;
	    uBlitzer[blitzerid][ubGebiet] = -1;
		uBlitzer[blitzerid][ubID] = -1;
		uBlitzer[blitzerid][ubX] = 0;
		uBlitzer[blitzerid][ubY] = 0;
		uBlitzer[blitzerid][ubAng] = 0;
		uBlitzer[blitzerid][ubMaxSpeed] = 0;
		uBlitzer[blitzerid][ubErstellt] = false;
		return 1;
	}
	return 0;
}

stock IsBlitzer(id)
{
    if(uBlitzer[id][ubID] != -1)
    {
        return 1;
    }
	return 0;
}
stock IsBlitzerArea(area)
{
	for(new i; i < MAX_U_BLITZER; i++)
	{
	    if(IsBlitzer(i))
	    {
		    if(uBlitzer[i][ubGebiet] == area)
		    {
		        return i;
		    }
	    }
	}
	return -1;
}
stock IsPlayerInRangeOfBlitzer(playerid)
{
	for(new i; i < MAX_U_BLITZER; i++)
	{
		if(IsBlitzer(i))
		{
		    if(IsPlayerInDynamicArea(playerid, uBlitzer[i][ubGebiet]))
		    {
		        return 1;
		    }
	    }
	}
	return 0;
}

stock GetBlitzerID(playerid)
{
	for(new i; i < MAX_U_BLITZER; i++)
	{
	    if(IsBlitzer(i))
	    {
		    if(IsPlayerInDynamicArea(playerid, uBlitzer[i][ubGebiet]))
		    {
		        return i;
		    }
	    }
	}
	return -1;
}

stock LoadBlitzer()
{
	new rows, buffer[24], DBResult:result, slot;
	result = db_query(BlitzerDB, "SELECT * FROM `Blitzer`");
	rows = db_num_rows(result);
	if(rows == 0) return print("* 0 Blitzer geladen *");
	for(new i; i < rows; i++)
	{
	    db_get_field(result, 0, buffer, sizeof(buffer)), slot = strval(buffer), uBlitzer[slot][ubID] = slot;
		db_get_field(result, 1, buffer, sizeof(buffer)), uBlitzer[slot][ubX] = floatstr(buffer);
		db_get_field(result, 2, buffer, sizeof(buffer)), uBlitzer[slot][ubY] = floatstr(buffer);
		db_get_field(result, 3, buffer, sizeof(buffer)), uBlitzer[slot][ubZ] = floatstr(buffer);
		db_get_field(result, 4, buffer, sizeof(buffer)), uBlitzer[slot][ubAng] = floatstr(buffer);
		db_get_field(result, 5, buffer, sizeof(buffer)), uBlitzer[slot][ubMaxSpeed] = strval(buffer);
		uBlitzer[slot][ubObject] = CreateDynamicObject(18880, uBlitzer[slot][ubX], uBlitzer[slot][ubY], uBlitzer[slot][ubZ]-1.2, 0.0, 0.0, uBlitzer[slot][ubAng]);
		uBlitzer[slot][ubGebiet] = CreateDynamicRectangle(uBlitzer[slot][ubX]-10, uBlitzer[slot][ubY]-10, uBlitzer[slot][ubX]+10, uBlitzer[slot][ubY]+10);
		uBlitzer[slot][ubErstellt] = true;
	    db_next_row(result);
	}
	db_free_result(result);
	printf("* %i Blitzer geladen *", rows);
	return 1;
}

//////////////////////////////////////////////////////////////////////\Callback Hooking\//////////////////////////////////////////////////////////////////////////////

public OnPlayerEnterDynamicArea(playerid, areaid)
{
    new isbarea = IsBlitzerArea(areaid);
    if(isbarea != -1)
    {
        #if !defined BLITZER_USE_GETVEHICLESPEED
			new Float:speed_x, Float:speed_y, Float:speed_z;
			GetVehicleVelocity(GetPlayerVehicleID(playerid),speed_x,speed_y,speed_z);
			new speed = floatround((floatsqroot(((speed_x*speed_x)+(speed_y*speed_y))+(speed_z*speed_z))*140), floatround_round);
		#else
			new speed = GetVehicleSpeed(GetPlayerVehicleID(playerid));
		#endif
		if(speed > uBlitzer[isbarea][ubMaxSpeed]+BLITZER_KMH_TOLERANZ)
		{
	        if(IsPlayerInAnyVehicle(playerid) && GetPlayerVehicleSeat(playerid) == 0)
	        {
				CallLocalFunction("OnPlayerBlitzed", "iiii", playerid, uBlitzer[isbarea][ubID], speed, uBlitzer[isbarea][ubMaxSpeed]+BLITZER_KMH_TOLERANZ);
			}
    	}
	}
    state _ALS_:hooked;
	return Hooked_OnPlayerEnterDynamicArea(playerid, areaid);
}

forward Hooked_OnPlayerEnterDynamicArea(playerid, areaid);

#if defined _ALS_OnPlayerEnterDynamicArea
    #undef OnPlayerEnterDynamicArea
#else
    #define _ALS_OnPlayerEnterDynamicArea
#endif


public Hooked_OnPlayerEnterDynamicArea(playerid, areaid) <_ALS_:unhooked> return 1;
public Hooked_OnPlayerEnterDynamicArea(playerid, areaid) <> return 1;

#define OnPlayerEnterDynamicArea(%0,%1) Hooked_OnPlayerEnterDynamicArea(%0,%1)<_ALS_:hooked>

#if !defined BLITZER_NO_SAVE
#if !defined BLITZER_USE_ONLY_IN_FS
public OnGameModeInit()
{
    BlitzerDB = db_open("Blitzer.db");
    db_free_result(db_query(BlitzerDB, "CREATE TABLE IF NOT EXISTS `Blitzer` (`bID` INT(11) NOT NULL, `bX` FLOAT NOT NULL, `bY` FLOAT NOT NULL, `bZ` FLOAT NOT NULL, `bRZ` FLOAT NOT NULL, `bMaxSpeed` INT(11) NOT NULL)"));
    LoadBlitzer();
    state _ALS_:hooked;
	return Hooked_OnGameModeInit();
}

forward Hooked_OnGameModeInit();

#if defined _ALS_OnGameModeInit
    #undef OnGameModeInit
#else
    #define _ALS_OnGameModeInit
#endif

public Hooked_OnGameModeInit() <_ALS_:unhooked> return 1;
public Hooked_OnGameModeInit() <> return 1;
#define OnGameModeInit(%0) Hooked_OnGameModeInit(%0)<_ALS_:hooked>

public OnGameModeExit()
{
	db_close(BlitzerDB);
	state _ALS_:hooked;
	return Hooked_OnGameModeExit();
}

forward Hooked_OnGameModeExit();

#if defined _ALS_OnGameModeExit
    #undef OnGameModeExit
#else
    #define _ALS_OnGameModeExit
#endif

public Hooked_OnGameModeExit() <_ALS_:unhooked> return 1;
public Hooked_OnGameModeExit() <> return 1;
#define OnGameModeExit(%0) Hooked_OnGameModeExit(%0)<_ALS_:hooked>
#else
public OnFilterScriptInit()
{
    BlitzerDB = db_open("Blitzer.db");
    db_free_result(db_query(BlitzerDB, "CREATE TABLE IF NOT EXISTS `Blitzer` (`bID` INT(11) NOT NULL, `bX` FLOAT NOT NULL, `bY` FLOAT NOT NULL, `bZ` FLOAT NOT NULL, `bRZ` FLOAT NOT NULL, `bMaxSpeed` INT(11) NOT NULL)"));
    LoadBlitzer();
    state _ALS_:hooked;
	return Hooked_OnFilterScriptInit();
}

forward Hooked_OnFilterScriptInit();

#if defined _ALS_OnFilterScriptInit
    #undef OnFilterScriptInit
#else
    #define _ALS_OnFilterScriptInit
#endif

public Hooked_OnFilterScriptInit() <_ALS_:unhooked> return 1;
public Hooked_OnFilterScriptInit() <> return 1;
#define OnFilterScriptInit(%0) Hooked_OnFilterScriptInit(%0)<_ALS_:hooked>

public OnFilterScriptExit()
{
	db_close(BlitzerDB);
	state _ALS_:hooked;
	return Hooked_OnFilterScriptExit();
}

forward Hooked_OnFilterScriptExit();

#if defined _ALS_OnFilterScriptExit
    #undef OnFilterScriptExit
#else
    #define _ALS_OnFilterScriptExit
#endif

public Hooked_OnFilterScriptExit() <_ALS_:unhooked> return 1;
public Hooked_OnFilterScriptExit() <> return 1;

#define OnFilterScriptExit(%0) Hooked_OnFilterScriptExit(%0)<_ALS_:hooked>
#endif
#endif