--[[
	$Id: behind.lua 196 2014-05-03 18:51:02Z dx $
	
	Maintain status with respect to target, if were in front or behind it
--]]
require "addresses"
require "classes"

CVector = class(
	function(self, X, Y, Z)
		self.X, self.Y, self.Z = X or 0, Y or 0, Z or 0

		-- Setup metatable
		metatable = {}
		metatable.__tostring = self.__tostring
		metatable.__add = self.__add
		metatable.__sub = self.__sub
		metatable.__index = CVector
		setmetatable(self, metatable)
	end
)

function CVector.__tostring(v)
	return "("..v.X..", "..v.Y..", "..v.Z..")"
end

function CVector.__add(v1, v2)
	return CVector(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z)
end

function CVector.__sub(v1, v2)
	return CVector(v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z)
end

function CVector:Dot(v)
	return self.X * v.X + self.Y * v.Y + self.Z * v.Z
end

function CVector:Len()
	return math.sqrt(self:Dot(self))
end

function CVector:Normalize()
	local l = self:Len()
	if l > 0 then
		local t = 1/l
		local res = CVector()
		
		res.X = self.X*t
		res.Y = self.Y*t
		res.Z = self.Z*t
		
		return res
	end
	return nil
end

CTest = class(CVector, 
	function(self)
		self.X, self.Y, self.Z = 0,0,0
	end
)

CPawnDirection = class(CVector,
	function(self, pawnAddress)
		self.X = mem.memoryReadFloat(0, pawnAddress + addresses.pawnDirXUVec_offset)
		self.Y = mem.memoryReadFloat(0, pawnAddress + addresses.pawnDirYUVec_offset)
		self.Z = mem.memoryReadFloat(0, pawnAddress + addresses.pawnDirZUVec_offset)
	end
)

CPawnLocation = class(CVector,
	function(self, pawnAddress)
		self.X = mem.memoryReadFloat(0, pawnAddress + addresses.pawnX_offset)
		self.Y = mem.memoryReadFloat(0, pawnAddress + addresses.pawnY_offset)
		self.Z = mem.memoryReadFloat(0, pawnAddress + addresses.pawnZ_offset)
	end
)

function isBehind()
	-- Find player
	local playerAddress = mem.memoryReadUIntPtr(0, addresses.staticbase_char, addresses.charPtr_offset)
	
	-- Find target
	local targetAddress = mem.memoryReadUInt(0, playerAddress + addresses.pawnTargetPtr_offset) or 0
	
	-- We have a target which is not ourself?
	if targetAddress == 0 or targetAddress == nil or playerAddress == targetAddress then
		return nil
	end
	
	-- Valid target?
	local targetId = mem.memoryReadUInt(0, targetAddress + addresses.pawnId_offset) or 0
	if targetId == 0 then
		return nil
	end
	
	-- Target alive?
	local HP = mem.memoryReadInt(0, targetAddress + addresses.pawnHP_offset) or 0
	if HP == 0 then
		return nil
	end
	
	-- Now, we have a target, calculate the target-player vector normalized
	local vtp = (CPawnLocation(targetAddress) - CPawnLocation(playerAddress))
	
	-- Add up the the target-player vector and target-direction vector
	local vsum = CPawnDirection(targetAddress) + vtp:Normalize()
	
	-- Calculate the length of it, if its longer than sqrt(2) were behind - so skip sqrts on both
	return (vsum:Dot(vsum) >= 2)
end