--[[------------------------------------------------------------------------

	Wraith Radar System - v1.0.3
	Created by WolfKnight

------------------------------------------------------------------------]]--

--[[------------------------------------------------------------------------
	Resource Rename Fix 
------------------------------------------------------------------------]]--
Citizen.CreateThread( function()
	-- Wait for a short period of time to give the resource time to load
	Citizen.Wait( 5000 )

	-- Get the name of the resource, for example the default name is 'wk_wrs'
	local resourceName = GetCurrentResourceName()

	-- Send a message through the NUI system to the JavaScript file to 
	-- give the name of the resource 
	SendNUIMessage( { resourcename = resourceName } )
end )

--[[------------------------------------------------------------------------
	Radar variables
------------------------------------------------------------------------]]--
RADAR.vars = 
{
	-- Player's vehicle speed 
	patrolSpeed = 0,

	-- The speed type
	speedType = "mph",

	-- Table to store entity IDs of captured vehicles 
	capturedVehicles = {}, 

	captureOffsets = {},

	-- Antennas 
	antennas = {
		front = {

		}, 

		back = {

		}
	}
}

--[[------------------------------------------------------------------------
	Radar setters and getters 
------------------------------------------------------------------------]]--
function RADAR:SetPatrolSpeed( speed )
	if ( type( speed ) == "number" ) then 
		self.vars.patrolSpeed = speed
	end
end

function RADAR:GetPatrolSpeed()
	return self.vars.patrolSpeed
end 

--[[------------------------------------------------------------------------
	Radar functions 
------------------------------------------------------------------------]]--
function RADAR:GetVehSpeed( veh )
	if ( self.vars.speedType == "mph" ) then 
		return GetEntitySpeed( veh ) * 2.236936
	else 
		return GetEntitySpeed( veh ) * 3.6
	end 
end 

function RADAR:ResetCapturedVehicles()
	self.vars.capturedVehicles = {}
end


local entityEnumerator = {
  __gc = function(enum)
	if enum.destructor and enum.handle then
	  enum.destructor(enum.handle)
	end
	enum.destructor = nil
	enum.handle = nil
  end
}

local function EnumerateEntities(initFunc, moveFunc, disposeFunc)
  return coroutine.wrap(function()
	local iter, id = initFunc()
	if not id or id == 0 then
	  disposeFunc(iter)
	  return
	end
	
	local enum = {handle = iter, destructor = disposeFunc}
	setmetatable(enum, entityEnumerator)
	
	local next = true
	repeat
	  coroutine.yield(id)
	  next, id = moveFunc(iter)
	until not next
	
	enum.destructor, enum.handle = nil, nil
	disposeFunc(iter)
  end)
end

function EnumeratePeds()
  return EnumerateEntities(FindFirstPed, FindNextPed, EndFindPed)
end

function EnumerateVehicles()
  return EnumerateEntities(FindFirstVehicle, FindNextVehicle, EndFindVehicle)
end


local traces = 
{
	{ startVec = { x = 0.0, y = 5.0 }, endVec = { x = 0.0, y = 150.0 } },

	-- "Forward cone"
	{ startVec = { x = -5.0, y = 15.0 }, endVec = { x = -5.0, y = 150.0 } },
	{ startVec = { x = 5.0, y = 15.0 }, endVec = { x = 5.0, y = 150.0 } },
	{ startVec = { x = -10.0, y = 25.0 }, endVec = { x = -10.0, y = 150.0 } },
	{ startVec = { x = 10.0, y = 25.0 }, endVec = { x = 10.0, y = 150.0 } },
	{ startVec = { x = -15.0, y = 35.0 }, endVec = { x = -15.0, y = 150.0 } },
	{ startVec = { x = 15.0, y = 35.0 }, endVec = { x = 15.0, y = 150.0 } },

	-- "Rear cone"
	--[[{ startVec = { x = -2.5, y = 135.0 }, endVec = { x = -2.5, y = 15.0 } },
	{ startVec = { x = 2.5, y = 135.0 }, endVec = { x = 2.5, y = 15.0 } },
	{ startVec = { x = -7.5, y = 125.0 }, endVec = { x = -7.5, y = 25.0 } },
	{ startVec = { x = 7.5, y = 125.0 }, endVec = { x = 7.5, y = 25.0 } },
	{ startVec = { x = -12.5, y = 115.0 }, endVec = { x = -12.5, y = 35.0 } },
	{ startVec = { x = 12.5, y = 115.0 }, endVec = { x = 12.5, y = 35.0 } }]]
}

function RADAR:RayTraceFromVeh( playerVeh )
	local playerVehPos = GetEntityCoords( playerVeh, true )
	local forwardVector = GetEntityForwardVector( playerVeh ) 

	-- Vector3 source = playerVehPos + forwardVector * Start.Y (15.0) + Game.Player.Character.CurrentVehicle.RightVector * Start.X (-5.0)
	--local rayStart1 = playerVehPos + ( forwardVector * vector3( -5.0, 15.0, 0.0 ) ) + GetEntityRotation( playerVeh, false )
	--local rayEnd1 = playerVehPos + ( forwardVector * vector3( -5.0, 300.0, 0.0 ) ) + GetEntityRotation( playerVeh, false )

	local offset = GetOffsetFromEntityInWorldCoords( playerVeh, 0.0, 60.0, 0.0 )

	-- for veh in EnumerateVehicles() do 
	-- 	local pos = GetEntityCoords( veh, true )

	-- 	local dist = GetDistanceBetweenCoords( pos.x, pos.y, pos.z, offset.x, offset.y, offset.z, true )

	-- 	UTIL:DrawDebugText( 0.50, 0.50, 0.60, true, "Dist: " .. tostring( dist ), 255, 255, 255, 255 )
	-- end 

	for k, v in pairs( traces ) do
		local rayStart1 = GetOffsetFromEntityInWorldCoords( playerVeh, v.startVec.x, v.startVec.y, 0.0 )
		local rayEnd1 = GetOffsetFromEntityInWorldCoords( playerVeh, v.endVec.x, v.endVec.y, 0.0 )

		DrawLine( rayStart1.x, rayStart1.y, rayStart1.z, rayEnd1.x, rayEnd1.y, rayEnd1.z, 255, 255, 255, 255 )

		local rayHandle = StartShapeTestCapsule( rayStart1.x, rayStart1.y, rayStart1.z, rayEnd1.x, rayEnd1.y, rayEnd1.z, 20.0, 10, playerVeh )
		local _, hitEntity, endCoords, surfaceNormal, vehicle = GetShapeTestResult( rayHandle )

		-- SetEntityAsMissionEntity( vehicle )

		UTIL:DrawDebugText( 0.50, ( k * 0.040 ) + 0.6, 0.60, true, "Found entity: " .. tostring( vehicle ), 255, 255, 255, 255 )

		local hitEntPos = GetEntityCoords( vehicle, true  )
		DrawMarker( 28, hitEntPos.x, hitEntPos.y, hitEntPos.z + 6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 2.0, 2.0, 0.5, 0, 250, 0, 200, false, true, 2, false, false, false, false )
	end
end

function RADAR:DoesLineIntersectSphere( centre, radiusSqr, rayStart, rayEnd )
	-- First we get the normalised ray, this way we then know the direction the ray is going 
	local rayNorm = norm( rayEnd - rayStart )

	-- Then we calculate the ray to the centre position of the sphere
	local rayToCentre = vehPos - startPoint 

	-- Now that we have the ray to the centre of the sphere, and the normalised ray direction, we 
	-- can calculate the shortest point from the centre of the sphere onto the ray itself. This 
	-- would then give us the opposite side of the right angled triangle. All of the resulting 
	-- values are also in squared form, as performing sqrt functions is slower. 
	local tProj = dot( rayToCentre, rayNorm )
	local oppLenSqr = dot( rayToCentre, rayToCentre ) - ( tProj * tProj )

	-- Now all we have to do is compare the squared opposite length and the radius squared, this 
	-- will then tell us if the ray intersects with the sphere.
	if ( oppLenSqr < radiusSqr ) then 
		return true 
	end

	return false
end 

--[[------------------------------------------------------------------------
	Test time 
------------------------------------------------------------------------]]--
function GetBoundingBox( ent )
	local mdl = GetEntityModel( ent )
	local min, max = GetModelDimensions( mdl )
	-- local radius = 5.0 

	-- min = min + -radius
	-- max = max + radius

	local points = {
		vector3( min.x, min.y, min.z ), -- Bottom back left 
		vector3( max.x, min.y, min.z ), -- Bottom back right 
		vector3( min.x, max.y, min.z ), -- Bottom front left
		vector3( max.x, max.y, min.z ), -- Bottom front right 
		vector3( min.x, min.y, max.z ), -- Top back left 
		vector3( max.x, min.y, max.z ), -- Top back right 
		vector3( min.x, max.y, max.z ), -- Top front left
		vector3( max.x, max.y, max.z )  -- Top front right 
	}

	return points
end 

function GetDrawableFromBoundingBox( box )
	local points = {
		{ box[1], box[3] },
		{ box[3], box[4] },
		{ box[4], box[2] }, 
		{ box[2], box[1] },

		{ box[1], box[5] }, 
		{ box[3], box[7] },
		{ box[4], box[8] }, 
		{ box[2], box[6] },

		{ box[5], box[7] },
		{ box[7], box[8] }, 
		{ box[8], box[6] },
		{ box[6], box[5] }
	}

	return points 
end

function DrawBoundingBox( ent, box )
	for _, v in pairs( box ) do
		local a = GetOffsetFromEntityInWorldCoords( ent, v[1] )
		local b = GetOffsetFromEntityInWorldCoords( ent, v[2] )

		DrawLine( a.x, a.y, a.z, b.x, b.y, b.z, 255, 255, 255, 255 )
	end
end

function GetAllVehicleEnts()
	local ents = {}

	for v in EnumerateVehicles() do 
		table.insert( ents, v )
	end

	return ents
end

function CustomShapeTest( startPos, endPos, entToIgnore )
	local flags = 1 | 2 | 4 | 16 | 256
	local trace = StartShapeTestRay( startPos, endPos, flags, entToIgnore, 7 )
	local _, didHit, hitPos, _, hitEnt = GetShapeTestResult( trace )

	UTIL:DrawDebugText( 0.500, 0.850, 0.55, true, "Hit?: " .. tostring( didHit ) .. "\nHit pos: " .. tostring( hitPos ) .. "\nHit ent: " .. tostring( hitEnt ) )	

	if ( hitPos ) then 
		DrawMarker( 28, hitPos.x, hitPos.y, hitPos.z + 5.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.25, 0, 250, 120, 200, false, true, 2, false, false, false, false )
	end 
end

function values(xs)
  local i = 0
  return function()
	i = i + 1;
	return xs[i]
  end
end

function map(xs, fn)
  local t = {}
  for i,v in ipairs(xs) do
	local r = fn(v, i, xs)
	table.insert(t, r)
  end
  return t
end

function filter(xs, fn)
  local t = {}
  for i,v in ipairs(xs) do
	if fn(v, i, xs) then
	  table.insert(t, v)
	end
  end
  return t
end


function DoesLineIntersectAABB( p1, p2, min, max )
	-- I know this probably isn't the best way to check if a line with a 'radius' intersects with 
	-- a bounding box, but it's a lot less resource intensive so...
	--local min = min + -3.0 
	--local max = max + 3.0

	-- This checks to make sure the origin of the line doesn't start inside the box
	-- Also known as "IsPointInsideAABB"
	if ( ( p1.x > min.x and p1.x < max.x and p1.y > min.y and p1.y < max.y and p1.z > min.z and p1.z < max.z ) or
		 ( p2.x > min.x and p2.x < max.x and p2.y > min.y and p2.y < max.y and p2.z > min.z and p2.z < max.z ) ) then 
		return true 
	end

	-- This checks to make sure the line itself is not even near the box
    for a in values( { 'x', 'y', 'z' } ) do
    	-- The first half of this statement checks to see if the axis origin and end line points 
    	-- are less than the minimum of the bounding box, the second half checks the start and 
    	-- end line points are beyond the maximum of the bounding box 
    	if ( ( p1[a] < min[a] and p2[a] < min[a] ) or ( p1[a] > max[a] and p2[a] > max[a] ) ) then
    		return false
    	end
    end

    -- Still trying to work out how this one works 
    for p in values( { min, max } ) do
    	for a, o in pairs( { x = { 'y', 'z' }, y = { 'x', 'z' }, z = { 'x', 'y' } } ) do

    		-- p = min or max as vector 
    		-- a = x, y or z 
    		-- o = 'y''z', 'x''z' or 'x''y' respectively
    		-- eg h = l1 + ( l1[x] - min[x] ) / ( l1[x] - l2[x] ) * ( l2 - l1 )
    		-- eg o1, o2 = [o1], o[2] = 'y', 'z'

    		-- The below variable h appears to calculate the values that allow for x1, x2, y1, and y2
    		-- This way the intersection point can be found 
    		local h = p1 + ( p1[a] - p[a] ) / ( p1[a] - p2[a] ) * ( p2 - p1 )
    		local o1, o2 = o[1], o[2]

    		if ( h[o1] >= min[o1] and h[o1] <= max[o1] and h[o2] >= min[o2] and h[o2] <= max[o2] ) then
    			return true
    		end
    	end
    end

    return false
end

function DoesLineIntersectSphere()
end

function DoesLineIntersectEntityBoundingBox(p1, p2, entity)
  local model = GetEntityModel(entity)
  local min, max = GetModelDimensions(model)

  local l1 = GetOffsetFromEntityGivenWorldCoords( entity, p1 )
  local l2 = GetOffsetFromEntityGivenWorldCoords( entity, p2 )

  -- Citizen.Trace( "\np1: " .. tostring( p1 ) .. "\tp2: " .. tostring( p2 ) .. "\tl1: " .. tostring( l1 ) .. "\tl2: " .. tostring( l2 ) )

  return DoesLineIntersectAABB(l1, l2, min, max)
end


function RaytraceBoundingBox(p1, p2, ignoredEntity)
  local entities = GetAllVehicleEnts()
  local matches = filter(entities, function (entity)
	if entity == ignoredEntity then return false end
	if not IsEntityOnScreen(entity) then return false end
	-- if not IsEntityTargetable(entity) then return false end
	return DoesLineIntersectEntityBoundingBox(p1, p2, entity)
  end)

  table.sort(matches, function (a, b)
	local h1 = GetEntityCoords(a)
	local h2 = GetEntityCoords(b)
	return #(p1 - h1) < #(p1 - h2)
  end)

  if matches[1] then
	local pos = GetEntityCoords(matches[1])
	return pos, matches[1]
  end

  return nil, nil
end


function RADAR:Test()
	-- Get the player's ped 
	local ped = GetPlayerPed( -1 )

	-- Make sure the player is sitting in a vehicle 
	if ( IsPedSittingInAnyVehicle( ped ) ) then 
		-- Get the vehicle the player is in 
		local plyVeh = GetVehiclePedIsIn( ped, false )
		local plyVehPos = GetEntityCoords( plyVeh )

		-- Check the vehicle actually exists and that the player is in the driver's seat
		if ( DoesEntityExist( plyVeh ) and GetPedInVehicleSeat( plyVeh, -1 ) ) then 
			local startPoint = GetOffsetFromEntityInWorldCoords( plyVeh, 0.0, -5.0, 0.0 )
			local endPoint = GetOffsetFromEntityInWorldCoords( plyVeh, 0.0, -50.0, 1.0 )
			DrawLine( startPoint, endPoint, 0, 255, 0, 255 )

			--for veh in EnumerateVehicles() do

			local veh = UTIL:GetVehicleInDirection( plyVeh, startPoint, endPoint )

			if ( DoesEntityExist( veh ) ) then 
				local vehPos = GetEntityCoords( veh )
				local vehPosRel = GetOffsetFromEntityGivenWorldCoords( plyVeh, vehPos )

				--[[local vehBox = GetBoundingBox( veh )
				local drawableBox = GetDrawableFromBoundingBox( vehBox )
				DrawBoundingBox( veh, drawableBox )]]

				if ( veh ~= plyVeh ) then 
					DrawMarker( 28, vehPos.x, vehPos.y, vehPos.z, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10.0, 10.0, 10.0, 255, 120, 80, 40, false, true, 2, false, false, false, false )

					-- First attempt, didn't really work 
					-- local r = 5.0 
					-- local ro = startPoint 
					-- local s = vehPos
					-- local rd = norm( startPoint )
					-- local t = dot( s - ro, rd )
					-- local p = ro + ( rd * t )

					-- UTIL:DrawDebugSphere( ro.x, ro.y, ro.z, 0.5 )
					-- UTIL:DrawDebugSphere( s.x, s.y, s.z, 0.5 )
					-- UTIL:DrawDebugSphere( p.x, p.y, p.z, 0.5 )

					-- local y = #( s - p )

					-- if ( y < r ) then 
					-- 	local x = math.sqrt( ( r * r ) - ( y * y ) )
					-- 	local t1 = t - x
					-- 	local t2 = t + x

					-- 	UTIL:DrawDebugText( 0.500, 0.700, 0.50, true, "t1: " .. tostring( t1 ) .. "\nt2: " .. tostring( t2 ) )
					-- end

					-- Second attempt 
					-- local ra = 20.0 
					-- local ce = vehPos 
					-- local ro = startPoint 
					-- local rd = norm( startPoint )

					-- local oc = ro - ce 
					-- local b = dot( oc, rd )
					-- local c = dot( oc, oc ) - ( ra * ra )
					-- local h = ( b * b ) - c 

					-- if ( h > 0.0 ) then 
					-- 	h = math.sqrt( h )
					-- 	local result = vector2( -b-h, -b+h )

					-- 	UTIL:DrawDebugText( 0.500, 0.700, 0.50, true, "Result: " .. tostring( result ) )
					-- end 

					-- Third bloody attempt 
					-- local center = vehPos 
					-- local radius = 5.0 
					-- local ro = startPoint 
					-- local rd = norm( startPoint )

					-- local oc = startPoint - center 
					-- local a = dot( rd, rd )
					-- local b = 2.0 * dot( oc, rd )
					-- local c = dot( oc, oc ) - radius * radius 
					-- local dis = b * b - 4 * a * c 

					-- if ( dis < 0 ) then 
					-- 	UTIL:DrawDebugText( 0.500, 0.650, 0.50, true, "-1" )
					-- else 
					-- 	local val = ( -b - math.sqrt( dis ) ) / ( 2.0 * a )
					-- 	UTIL:DrawDebugText( 0.500, 0.650, 0.50, true, "yes" )
					-- end 

					-- Fourth attempt 
					local offset = GetOffsetFromEntityGivenWorldCoords( veh, startPoint )
					UTIL:DrawDebugText( 0.500, 0.550, 0.50, true, tostring( offset ) )

					local radius = 10.0 
					local radiusSqr = radius * radius 

					local rayNorm = norm( endPoint - startPoint )
					UTIL:DrawDebugText( 0.500, 0.600, 0.50, true, "rayNorm: " .. tostring( rayNorm ) )

					local rayToCenter = vehPos - startPoint 
					DrawLine( startPoint, vehPos, 255, 255, 255, 255 )

					local tProj = dot( rayToCenter, rayNorm )
					UTIL:DrawDebugText( 0.500, 0.625, 0.50, true, "tProj: " .. tostring( tProj ) )

					UTIL:DrawDebugText( 0.500, 0.100, 0.60, true, "Veh in front? = " .. tostring( ( tProj > 0 ) ) )

					local iPos = ( rayNorm * tProj ) + startPoint 
					DrawLine( vehPos, iPos, 255, 255, 255, 255 ) -- draw the smallest point 
					DrawLine( startPoint, iPos, 255, 255, 255, 255 ) -- draw a line on the opposite 

					local oppLenSqr = dot( rayToCenter, rayToCenter ) - ( tProj * tProj )
					UTIL:DrawDebugText( 0.500, 0.650, 0.50, true, "radiusSqr: " .. tostring( radiusSqr ) )
					UTIL:DrawDebugText( 0.500, 0.675, 0.50, true, "oppLenSqr: " .. tostring( oppLenSqr ) )

					if ( oppLenSqr > radiusSqr ) then 
						UTIL:DrawDebugText( 0.500, 0.800, 0.50, true, "Projection point outside radius" )
					elseif ( oppLenSqr == radiusSqr ) then 
						UTIL:DrawDebugText( 0.500, 0.825, 0.50, true, "Single point intersection" )
					end 

					local oLen = math.sqrt( radiusSqr - oppLenSqr )
					UTIL:DrawDebugText( 0.500, 0.700, 0.50, true, "oLen: " .. tostring( oLen ) )

					local t0 = tProj - oLen 
					local t1 = tProj + oLen 

					if ( t1 < t0 ) then 
						local tmp = t0 
						t0 = t1 
						t1 = tmp 
					end 

					UTIL:DrawDebugText( 0.500, 0.725, 0.50, true, "t0: " .. tostring( t0 ) .. "\nt1: " .. tostring( t1 ) )

					local t0p = ( rayNorm * t0 ) + startPoint
					local t1p = ( rayNorm * t1 ) + startPoint

					UTIL:DrawDebugSphere( t0p.x, t0p.y, t0p.z, 0.25 )
					UTIL:DrawDebugSphere( t1p.x, t1p.y, t1p.z, 0.25 )

					DrawLine( vehPos, t0p, 255, 255, 0, 255 )
					DrawLine( vehPos, t1p, 255, 255, 0, 255 )

					if ( oppLenSqr < radiusSqr ) then 
						UTIL:DrawDebugText( 0.500, 0.875, 0.55, true, "Intersects sphere" )
					else
						UTIL:DrawDebugText( 0.500, 0.925, 0.55, true, "Doesn't intersect sphere" )
					end
				end
			end
		end
	end 
end 

function RADAR:Main()
	-- Get the local player's ped and store it in a variable 
	local ped = GetPlayerPed( -1 )

	-- As we only want the radar to work when a player is sitting in a
	-- vehicle, we run that check first
	if ( IsPedSittingInAnyVehicle( ped ) ) then 
		-- Get the vehicle the player is sitting in 
		local vehicle = GetVehiclePedIsIn( ped, false )

		UTIL:DrawDebugText( 0.50, 0.020, 0.60, true, "Found player vehicle: " .. tostring( vehicle ), 255, 255, 255, 255 )

		-- Check to make sure the player is in the driver's seat, and also 
		-- that the vehicle has a class of VC_EMERGENCY (18)
		if ( GetPedInVehicleSeat( vehicle, -1 ) == ped --[[ and GetVehicleClass( vehicle ) == 18 ]] ) then 
			local vehicleSpeed = UTIL:Round( self:GetVehSpeed( vehicle ), 0 )
			local vehicleHeading = UTIL:Round( GetEntityHeading( vehicle ), 0 )

			UTIL:DrawDebugText( 0.50, 0.060, 0.60, true, "Self speed: " .. tostring( vehicleSpeed ), 255, 255, 255, 255 )

			local vehiclePos = GetEntityCoords( vehicle, true )
			-- local edge = GetOffsetFromEntityInWorldCoords( vehicle, 20.0, 50.0, 0.0 ) 
		   
			local newX = UTIL:Round( vehiclePos.x, 0 )
			local newY = UTIL:Round( vehiclePos.y, 0 )
			local newZ = UTIL:Round( vehiclePos.z, 0 )

			UTIL:DrawDebugText( 0.50, 0.100, 0.60, true, "Vehicle X: " .. tostring( newX ) .. "  Vehicle Y: " .. tostring( newY ) .. " Vehicle Z: " .. tostring( newZ ), 255, 255, 255, 255 )

			local model = GetEntityModel( vehicle )
			local min, max = GetModelDimensions( model )
			local format = "Min X: " .. tostring( min.x ) .. " Min Y: " .. tostring( min.y ) .. " Min Z: " .. tostring( min.z )
			local format2 = "Max X: " .. tostring( max.x ) .. " Max Y: " .. tostring( max.y ) .. " Max Z: " .. tostring( max.z )

			UTIL:DrawDebugText( 0.50, 0.180, 0.60, true, "Model: " .. tostring( model ), 255, 255, 255, 255 )
			UTIL:DrawDebugText( 0.50, 0.220, 0.60, true, format, 255, 255, 255, 255 )
			UTIL:DrawDebugText( 0.50, 0.260, 0.60, true, format2, 255, 255, 255, 255 )

			for veh in EnumerateVehicles() do
				if ( GetEntitySpeed( veh ) > 1.0 and veh ~= vehicle ) then 
					local aiVehHeading = UTIL:Round( GetEntityHeading( veh ), 0 )
					local sameHeading = UTIL:IsEntityInMyHeading( vehicleHeading, aiVehHeading, 45 )

					if ( sameHeading ) then 
						local mdl = GetEntityModel( veh )

						if ( IsThisModelACar( mdl ) or IsThisModelABike( mdl ) or IsThisModelAQuadbike( mdl ) ) then 
							local bounds = getBoundingBox( veh )	
							local boundsDrawable = getBoundingBoxDrawable( bounds )
							drawBoundingBox( veh, boundsDrawable )
						end
					end
				end
			end

			-- self:RayTraceFromVeh( vehicle )

			-- local newPos = GetOffsetFromEntityInWorldCoords( vehicle, 0.0, 10.0, 0.0 )

			-- UTIL:DrawSphere( newPos.x, newPos.y, newPos.z, 6.0, 128, 255, 0, 0.15 )

			-- local ranVeh = GetRandomVehicleInSphere( newPos.x, newPos.y, newPos.z, 6.0, 0, 23 )

			-- UTIL:DrawDebugText( 0.50, 0.140, 0.60, true, "Found random vehicle: " .. tostring( ranVeh ), 255, 255, 255, 255 )

			-- if ( DoesEntityExist( ranVeh ) and IsEntityAVehicle( ranVeh ) ) then 
			-- 	local targetPos = GetEntityCoords( ranVeh, true )
			-- 	DrawMarker(2, targetPos.x, targetPos.y, targetPos.z + 6, 0.0, 0.0, 0.0, 0.0, 180.0, 0.0, 2.0, 2.0, 2.0, 255, 128, 0, 50, false, true, 2, nil, nil, false)
			-- end

			-- begin bubble test 
			-- for i = 1, 5 do 
			-- 	local newPos = GetOffsetFromEntityInWorldCoords( vehicle, 0.0, i * 10.0, 0.0 )
			-- 	-- UTIL:DrawSphere( newPos1.x, newPos1.y, newPos1.z, 2.0, 128, 255, 20, 0.4 )
			-- 	DrawMarker( 28, newPos.x, newPos.y, newPos.z, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, i * 2.0, i * 2.0, 0.5, 0, 250, 0, 200, false, true, 2, false, false, false, false )
			-- end
		end
	end
end 

Citizen.CreateThread( function()
	while ( true ) do
		-- RADAR:Main()
		RADAR:Test()

		Citizen.Wait( 0 )
	end
end )