/**

 * vim: set ts=4 :

 * =============================================================================

 * SourceMod SDKTools Extension

 * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.

 * =============================================================================

 *

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, version 3.0, as published by the

 * Free Software Foundation.

 * 

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

 * details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program.  If not, see <http://www.gnu.org/licenses/>.

 *

 * As a special exception, AlliedModders LLC gives you permission to link the

 * code of this program (as well as its derivative works) to "Half-Life 2," the

 * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

 * by the Valve Corporation.  You must obey the GNU General Public License in

 * all respects for all other code used.  Additionally, AlliedModders LLC grants

 * this exception to all derivative works.  AlliedModders LLC defines further

 * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

 * or <http://www.sourcemod.net/license.php>.

 *

 * Version: $Id$

 */

#include "extension.h"

#include <worldsize.h>

class CSMTraceFilter : public CTraceFilter

{

public:

	bool ShouldHitEntity(IHandleEntity *pEntity, int contentsMask)

	{

		cell_t res = 1;

		edict_t *pEdict = gameents->BaseEntityToEdict(reinterpret_cast<CBaseEntity *>(pEntity));

		m_pFunc->PushCell(engine->IndexOfEdict(pEdict));

		m_pFunc->PushCell(contentsMask);

		m_pFunc->PushCell(m_Data);

		m_pFunc->Execute(&res);

		return (res) ? true : false;

	}

	void SetFunctionPtr(IPluginFunction *pFunc, cell_t data)

	{

		m_pFunc = pFunc;

		m_Data = data;

	}

private:

	IPluginFunction *m_pFunc;

	cell_t m_Data;

};

/* Used for the global trace version */

Ray_t g_Ray;

trace_t g_Trace;

Vector g_StartVec;

Vector g_EndVec;

Vector g_HullMins;

Vector g_HullMaxs;

QAngle g_DirAngles;

CTraceFilterHitAll g_HitAllFilter;

CSMTraceFilter g_SMTraceFilter;

enum

{

	RayType_EndPoint,

	RayType_Infinite

};

static cell_t smn_TRTraceRay(IPluginContext *pContext, const cell_t *params)

{

	cell_t *startaddr, *endaddr;

	pContext->LocalToPhysAddr(params[1], &startaddr);

	pContext->LocalToPhysAddr(params[2], &endaddr);

	g_StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));

	switch (params[4])

	{

	case RayType_EndPoint:

		{

			g_EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

			break;

		}

	case RayType_Infinite:

		{

			g_DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

			AngleVectors(g_DirAngles, &g_EndVec);

			/* Make it unitary and get the ending point */

			g_EndVec.NormalizeInPlace();

			g_EndVec = g_StartVec + g_EndVec * MAX_TRACE_LENGTH;

			break;

		}

	}

	g_Ray.Init(g_StartVec, g_EndVec);

	enginetrace->TraceRay(g_Ray, params[3], &g_HitAllFilter, &g_Trace);

	return 1;

}

static cell_t smn_TRTraceHull(IPluginContext *pContext, const cell_t *params)

{

	cell_t *startaddr, *endaddr, *mins, *maxs;

	pContext->LocalToPhysAddr(params[1], &startaddr);

	pContext->LocalToPhysAddr(params[2], &endaddr);

	pContext->LocalToPhysAddr(params[3], &mins);

	pContext->LocalToPhysAddr(params[4], &maxs);

	g_StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));

	g_HullMins.Init(sp_ctof(mins[0]), sp_ctof(mins[1]), sp_ctof(mins[2]));

	g_HullMaxs.Init(sp_ctof(maxs[0]), sp_ctof(maxs[1]), sp_ctof(maxs[2]));

	g_EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

	g_Ray.Init(g_StartVec, g_EndVec, g_HullMins, g_HullMaxs);

	enginetrace->TraceRay(g_Ray, params[5], &g_HitAllFilter, &g_Trace);

	return 1;

}

static cell_t smn_TRTraceRayFilter(IPluginContext *pContext, const cell_t *params)

{

	cell_t *startaddr, *endaddr;

	IPluginFunction *pFunc;

	cell_t data;

	pFunc = pContext->GetFunctionById(params[5]);

	if (!pFunc)

	{

		return pContext->ThrowNativeError("Invalid function id (%X)", params[5]);

	}

	if (params[0] >= 6)

	{

		data = params[6];

	}

	else

	{

		data = 0;

	}

	g_SMTraceFilter.SetFunctionPtr(pFunc, data);

	pContext->LocalToPhysAddr(params[1], &startaddr);

	pContext->LocalToPhysAddr(params[2], &endaddr);

	g_StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));

	switch (params[4])

	{

	case RayType_EndPoint:

		{

			g_EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

			break;

		}

	case RayType_Infinite:

		{

			g_DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

			AngleVectors(g_DirAngles, &g_EndVec);

			/* Make it unitary and get the ending point */

			g_EndVec.NormalizeInPlace();

			g_EndVec = g_StartVec + g_EndVec * MAX_TRACE_LENGTH;

			break;

		}

	}

	g_Ray.Init(g_StartVec, g_EndVec);

	enginetrace->TraceRay(g_Ray, params[3], &g_SMTraceFilter, &g_Trace);

	return 1;

}

static cell_t smn_TRTraceHullFilter(IPluginContext *pContext, const cell_t *params)

{

	cell_t data;

	IPluginFunction *pFunc;

	cell_t *startaddr, *endaddr, *mins, *maxs;

	pFunc = pContext->GetFunctionById(params[6]);

	if (!pFunc)

	{

		return pContext->ThrowNativeError("Invalid function id (%X)", params[5]);

	}

	data = params[7];

	g_SMTraceFilter.SetFunctionPtr(pFunc, data);

	pContext->LocalToPhysAddr(params[1], &startaddr);

	pContext->LocalToPhysAddr(params[2], &endaddr);

	pContext->LocalToPhysAddr(params[3], &mins);

	pContext->LocalToPhysAddr(params[4], &maxs);

	g_StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));

	g_HullMins.Init(sp_ctof(mins[0]), sp_ctof(mins[1]), sp_ctof(mins[2]));

	g_HullMaxs.Init(sp_ctof(maxs[0]), sp_ctof(maxs[1]), sp_ctof(maxs[2]));

	g_EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

	g_Ray.Init(g_StartVec, g_EndVec, g_HullMins, g_HullMaxs);

	enginetrace->TraceRay(g_Ray, params[5], &g_SMTraceFilter, &g_Trace);

	return 1;

}

static cell_t smn_TRTraceRayEx(IPluginContext *pContext, const cell_t *params)

{

	cell_t *startaddr, *endaddr;

	pContext->LocalToPhysAddr(params[1], &startaddr);

	pContext->LocalToPhysAddr(params[2], &endaddr);

	Vector StartVec, EndVec;

	Ray_t ray;

	StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));

	switch (params[4])

	{

	case RayType_EndPoint:

		{

			EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

			break;

		}

	case RayType_Infinite:

		{

			QAngle DirAngles;

			DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

			AngleVectors(DirAngles, &EndVec);

			/* Make it unitary and get the ending point */

			EndVec.NormalizeInPlace();

			EndVec = StartVec + EndVec * MAX_TRACE_LENGTH;

			break;

		}

	}

	trace_t *tr = new trace_t;

	ray.Init(StartVec, EndVec);

	enginetrace->TraceRay(ray, params[3], &g_HitAllFilter, tr);

	HandleError herr;

	Handle_t hndl;

	if (!(hndl=handlesys->CreateHandle(g_TraceHandle, tr, pContext->GetIdentity(), myself->GetIdentity(), &herr)))

	{

		delete tr;

		return pContext->ThrowNativeError("Unable to create a new trace handle (error %d)", herr);

	}

	return hndl;

}

static cell_t smn_TRTraceHullEx(IPluginContext *pContext, const cell_t *params)

{

	cell_t *startaddr, *endaddr, *mins, *maxs;

	pContext->LocalToPhysAddr(params[1], &startaddr);

	pContext->LocalToPhysAddr(params[2], &endaddr);

	pContext->LocalToPhysAddr(params[3], &mins);

	pContext->LocalToPhysAddr(params[4], &maxs);

	Ray_t ray;

	Vector StartVec, EndVec, vmins, vmaxs;

	StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));

	vmins.Init(sp_ctof(mins[0]), sp_ctof(mins[1]), sp_ctof(mins[2]));

	vmaxs.Init(sp_ctof(maxs[0]), sp_ctof(maxs[1]), sp_ctof(maxs[2]));

	EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

	ray.Init(StartVec, EndVec, vmins, vmaxs);

	trace_t *tr = new trace_t;

	enginetrace->TraceRay(ray, params[5], &g_HitAllFilter, tr);

	HandleError herr;

	Handle_t hndl;

	if (!(hndl=handlesys->CreateHandle(g_TraceHandle, tr, pContext->GetIdentity(), myself->GetIdentity(), &herr)))

	{

		delete tr;

		return pContext->ThrowNativeError("Unable to create a new trace handle (error %d)", herr);

	}

	return hndl;

}

static cell_t smn_TRTraceRayFilterEx(IPluginContext *pContext, const cell_t *params)

{

	IPluginFunction *pFunc;

	cell_t *startaddr, *endaddr;

	cell_t data;

	pFunc = pContext->GetFunctionById(params[5]);

	if (!pFunc)

	{

		return pContext->ThrowNativeError("Invalid function id (%X)", params[5]);

	}

	pContext->LocalToPhysAddr(params[1], &startaddr);

	pContext->LocalToPhysAddr(params[2], &endaddr);

	Vector StartVec, EndVec;

	CSMTraceFilter smfilter;

	Ray_t ray;

	if (params[0] >= 6)

	{

		data = params[6];

	}

	else

	{

		data = 0;

	}

	smfilter.SetFunctionPtr(pFunc, data);

	StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));

	switch (params[4])

	{

	case RayType_EndPoint:

		{

			EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

			break;

		}

	case RayType_Infinite:

		{

			QAngle DirAngles;

			DirAngles.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

			AngleVectors(DirAngles, &EndVec);

			/* Make it unitary and get the ending point */

			EndVec.NormalizeInPlace();

			EndVec = StartVec + EndVec * MAX_TRACE_LENGTH;

			break;

		}

	}

	trace_t *tr = new trace_t;

	ray.Init(StartVec, EndVec);

	enginetrace->TraceRay(ray, params[3], &smfilter, tr);

	HandleError herr;

	Handle_t hndl;

	if (!(hndl=handlesys->CreateHandle(g_TraceHandle, tr, pContext->GetIdentity(), myself->GetIdentity(), &herr)))

	{

		delete tr;

		return pContext->ThrowNativeError("Unable to create a new trace handle (error %d)", herr);

	}

	return hndl;

}

static cell_t smn_TRTraceHullFilterEx(IPluginContext *pContext, const cell_t *params)

{

	IPluginFunction *pFunc;

	cell_t *startaddr, *endaddr, *mins, *maxs;

	cell_t data;

	pFunc = pContext->GetFunctionById(params[6]);

	if (!pFunc)

	{

		return pContext->ThrowNativeError("Invalid function id (%X)", params[5]);

	}

	pContext->LocalToPhysAddr(params[1], &startaddr);

	pContext->LocalToPhysAddr(params[2], &endaddr);

	pContext->LocalToPhysAddr(params[3], &mins);

	pContext->LocalToPhysAddr(params[4], &maxs);

	Vector StartVec, EndVec, vmins, vmaxs;

	CSMTraceFilter smfilter;

	Ray_t ray;

	data = params[7];

	smfilter.SetFunctionPtr(pFunc, data);

	StartVec.Init(sp_ctof(startaddr[0]), sp_ctof(startaddr[1]), sp_ctof(startaddr[2]));

	vmins.Init(sp_ctof(mins[0]), sp_ctof(mins[1]), sp_ctof(mins[2]));

	vmaxs.Init(sp_ctof(maxs[0]), sp_ctof(maxs[1]), sp_ctof(maxs[2]));

	EndVec.Init(sp_ctof(endaddr[0]), sp_ctof(endaddr[1]), sp_ctof(endaddr[2]));

	ray.Init(StartVec, EndVec, vmins, vmaxs);

	trace_t *tr = new trace_t;

	enginetrace->TraceRay(ray, params[5], &smfilter, tr);

	HandleError herr;

	Handle_t hndl;

	if (!(hndl=handlesys->CreateHandle(g_TraceHandle, tr, pContext->GetIdentity(), myself->GetIdentity(), &herr)))

	{

		delete tr;

		return pContext->ThrowNativeError("Unable to create a new trace handle (error %d)", herr);

	}

	return hndl;

}

static cell_t smn_TRGetFraction(IPluginContext *pContext, const cell_t *params)

{

	trace_t *tr;

	HandleError err;

	HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());

	if (params[1] == BAD_HANDLE)

	{

		tr = &g_Trace;

	} else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) {

		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);

	}

	return sp_ftoc(tr->fraction);

}

static cell_t smn_TRGetPlaneNormal(IPluginContext *pContext, const cell_t *params)

{

	trace_t *tr;

	HandleError err;

	HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());

	if (params[1] == BAD_HANDLE)

	{

		tr = &g_Trace;

	} else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) {

		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);

	}

	Vector *normal = &tr->plane.normal;

	cell_t *r;

	pContext->LocalToPhysAddr(params[2], &r);

	r[0] = sp_ftoc(normal->x);

	r[1] = sp_ftoc(normal->y);

	r[2] = sp_ftoc(normal->z);

	return 1;

}

static cell_t smn_TRGetEndPosition(IPluginContext *pContext, const cell_t *params)

{

	trace_t *tr;

	HandleError err;

	HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());

	if (params[2] == BAD_HANDLE)

	{

		tr = &g_Trace;

	} else if ((err = handlesys->ReadHandle(params[2], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) {

		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[2], err);

	}

	cell_t *addr;

	pContext->LocalToPhysAddr(params[1], &addr);

	addr[0] = sp_ftoc(tr->endpos.x);

	addr[1] = sp_ftoc(tr->endpos.y);

	addr[2] = sp_ftoc(tr->endpos.z);

	return 1;

}

static cell_t smn_TRDidHit(IPluginContext *pContext, const cell_t *params)

{

	trace_t *tr;

	HandleError err;

	HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());

	if (params[1] == BAD_HANDLE)

	{

		tr = &g_Trace;

	} else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) {

		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);

	}

	return tr->DidHit() ? 1 : 0;

}

static cell_t smn_TRGetHitGroup(IPluginContext *pContext, const cell_t *params)

{

	trace_t *tr;

	HandleError err;

	HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());

	if (params[1] == BAD_HANDLE)

	{

		tr = &g_Trace;

	} else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) {

		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);

	}

	return tr->hitgroup;

}

static cell_t smn_TRGetEntityIndex(IPluginContext *pContext, const cell_t *params)

{

	trace_t *tr;

	HandleError err;

	HandleSecurity sec(pContext->GetIdentity(), myself->GetIdentity());

	if (params[1] == BAD_HANDLE)

	{

		tr = &g_Trace;

	} else if ((err = handlesys->ReadHandle(params[1], g_TraceHandle, &sec, (void **)&tr)) != HandleError_None) {

		return pContext->ThrowNativeError("Invalid Handle %x (error %d)", params[1], err);

	}

	edict_t *pEdict = gameents->BaseEntityToEdict(tr->m_pEnt);

	return engine->IndexOfEdict(pEdict);

}

static cell_t smn_TRGetPointContents(IPluginContext *pContext, const cell_t *params)

{

	cell_t *vec, *ent;