// 
// Online Game Cheats Client.dll hook
// Copyright (c) system   2001-2002
// Copyright (c) bunny771 2001-2002
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// 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, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
// 
// NOTE:
// GNU license doesn't cover Engine directory.
// Content of Engine directory is copyrighted (c) 1999, 2000, by Valve LLC
// and it is licensed under Valve's proprietary license (see original HL SDK).
// 

#include <windows.h>

#include <stdlib.h>
#include <math.h>
#undef NDEBUG
#include <assert.h>
#include <memory.h>
#include <map>
#include <vector>
#include <fstream>

#include "engine/wrect.h"
#include "cl_dll.h"
#include "cdll_int.h"
#include "util_vector.h"
#include "cl_entity.h"
#include "common/com_model.h"
#include "common/event_api.h"
#include "engine/pmtrace.h" 
#include "engine/pm_defs.h"


#include "aimbot.h"
#include "cvar.h"
#include "client.h"
#include "interpreter.h"

#define BOUND_VALUE(var,min,max) if((var)>(max)){(var)=(max);};if((var)<(min)){(var)=(min);}
#define M_PI 3.14159265358979f

using namespace std;

//===================================================================================
BoneAimbot gAimbot;
#define gAimbot This define is to prevent usage of gAimbot in this file.

extern float mainViewOrigin[3],mainViewAngles[3];

//===================================================================================
void VectorAngles( const float *forward, float *angles )
{
	float	tmp, yaw, pitch;
	
	if (forward[1] == 0 && forward[0] == 0)
	{
		yaw = 0;
		if (forward[2] > 0)
			pitch = 90.0;
		else
			pitch = 270.0;
	}
	else
	{
		yaw = (float)(atan2(forward[1], forward[0]) * 180.0 / M_PI);
		
		if (yaw < 0) yaw += 360.0;

		tmp = (float)sqrt (forward[0]*forward[0] + forward[1]*forward[1]);
		
		pitch = (float)(atan2(forward[2], tmp) * 180 / M_PI);
	}
	
	angles[0] = pitch;
	angles[1] = yaw;
	angles[2] = 0;
}

//====================================================================================
bool pathFree(float* from,float* to)
{
	pmtrace_t tr;
	gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );

	gEngfuncs.pEventAPI->EV_PlayerTrace( from, to, PM_GLASS_IGNORE, me.ent->index, &tr );

	return ( tr.fraction == 1.0 ); 
}

//====================================================================================
bool IsAimingAtMe( int ax )
{
	vec3_t entViewOfs;
	vec3_t localViewOfs;

	cl_entity_s* ent_ax = vPlayers[ax].getEnt();
	cl_entity_s* ent_bx = me.ent;

	if ( ent_ax->curstate.usehull == 0 )
	{
	entViewOfs[0] = ent_ax->origin[0];
	entViewOfs[1] = ent_ax->origin[1];
	entViewOfs[2] = ent_ax->origin[2] + 17;
	}
	else
	{
	entViewOfs[0] = ent_ax->origin[0];
	entViewOfs[1] = ent_ax->origin[1];
	entViewOfs[2] = ent_ax->origin[2] + 12;
	}

	if ( ent_bx->curstate.usehull == 0 )
	{
	localViewOfs[0] = ent_bx->origin[0];
	localViewOfs[1] = ent_bx->origin[1];
	localViewOfs[2] = ent_bx->origin[2] + 17;
	}
	else
	{
	localViewOfs[0] = ent_bx->origin[0];
	localViewOfs[1] = ent_bx->origin[1];
	localViewOfs[2] = ent_bx->origin[2] + 12;
	}

	vec3_t m_vTraceVector;
	vec3_t m_vAimAngles;
	vec3_t m_vTempAngles;

	m_vTraceVector[0] = localViewOfs[0] - entViewOfs[0];
	m_vTraceVector[1] = localViewOfs[1] - entViewOfs[1];
	m_vTraceVector[2] = localViewOfs[2] - entViewOfs[2];

	VectorAngles(m_vTraceVector, m_vAimAngles);

	m_vAimAngles[0] *= -1;

	double variationPitch = m_vAimAngles[0] - ent_ax->angles[0];
	double variationYaw   = m_vAimAngles[1] - ent_ax->angles[1];

	if( variationPitch < 0     )  { variationPitch += 360.0; }
	if( variationYaw   < 0     )  { variationYaw   += 360.0; }
	
	if( variationPitch > 180.0 )  { variationPitch = 360.0 - variationPitch; }
	if( variationYaw   > 180.0 )  { variationYaw   = 360.0 - variationYaw;   }

	if( variationPitch<2 && variationYaw<3 ) { return true; }

	return false;
}

//===================================================================================
static void PredictTarget(int index,float *pred)
{
	if (cvar.pred)
	{
			cl_entity_s* ent = vPlayers[index].getEnt();
			int  historyIndex = (ent->current_position+HISTORY_MAX-cvar.predback)%HISTORY_MAX;
			
			vec3_t vFromOrigin , vToOrigin , vDeltaOrigin,vPredictedOrigin;

			vFromOrigin = ent->ph[historyIndex].origin;
			vToOrigin   = ent->ph[ent->current_position].origin;
			vDeltaOrigin = vToOrigin - vFromOrigin;

			vDeltaOrigin[0] *= cvar.predahead;
			vDeltaOrigin[1] *= cvar.predahead;
			vDeltaOrigin[2] *= cvar.predahead;

			vPredictedOrigin = ent->origin + vDeltaOrigin;
			VectorCopy(vPredictedOrigin,pred);
	}
	else 
	{
			VectorCopy(vPlayers[index].getEnt()->origin,pred);
	}
}

//===================================================================================
double OriginAimbot::GetAimingFov(int ax)
{
	double vec[3], view[3];
	double dot;	
	
	float* origin = vPlayers[ax].getEnt()->origin;
	view[0] = origin[0] - me.pmEyePos[0];
	view[1] = origin[1] - me.pmEyePos[1];
	view[2] = origin[2] - me.pmEyePos[2];

	dot = sqrt(view[0] * view[0] + view[1] * view[1] + view[2] * view[2]);
	dot = 1/dot;

	vec[0] = view[0] * dot;
	vec[1] = view[1] * dot;
	vec[2] = view[2] * dot;
	
	view[0] =  sin((me.viewAngles[1] + 90) * (M_PI / 180));
	view[1] = -cos((me.viewAngles[1] + 90) * (M_PI / 180));
	view[2] = -sin( me.viewAngles[0] * (M_PI / 180));	
	
	dot = view[0] * vec[0] + view[1] * vec[1] + view[2] * vec[2];
	
	return dot;
}

//===================================================================================
void OriginAimbot::calcFovangleAndVisibility(int ax)
{ 
	PlayerInfo& r = vPlayers[ax];
	r.fovangle = (float)((1.0-GetAimingFov(ax))*360.0); 
	
	// visibility: 
	if(0) {}
	else if(!GetAimingTeam(ax)) { r.visible = true; }
	else if(r.fovangle>10)      { r.visible = pathFree(vPlayers[ax].getEnt()->origin, me.pmEyePos); }
	else                        { r.visible = (TargetRegion(ax)!=NULL); }
}



//===================================================================================
void OriginAimbot::findTarget()
{
	// target locking
	if( cvar.lock && target!=-1 && vPlayers[target].getPVS() && GetPlayerVisX(target) )
	{
		return;
	}

	// scan for a new target
	target=-1;
	for (int ax=0;ax<vPlayers.size();ax++)
	if  ( 
		  vPlayers[ax].getPVS() 
		  && GetPlayerVisX(ax)     
		  && GetAimingTeam(ax)    
		  && vPlayers[ax].fovangle<cvar.fov 
		 )
	{
		if( target == -1 )                                       { target = ax; continue; }

		switch(cvar.mode)
		{
		default:
		case 0: // distance based 
			if( vPlayers[ax].visible  && !vPlayers[target].visible )  { target = ax; break; }
			if( vPlayers[ax].distance <  vPlayers[target].distance )  { target = ax; break; }
			break;
		case 1: // fov based
			if( vPlayers[ax].visible  && !vPlayers[target].visible )  { target = ax; break; }
			if( GetAimingFov(ax) >   GetAimingFov(target)  )          { target = ax; break; }
			break;
		case 2: // points based
			if( vPlayers[ax].points   >  vPlayers[target].points   )  { target = ax; break; }
			break;
		}
	} 
}

//==============================================================================
void OriginAimbot::draw()
{
	for (int ax=0;ax<vPlayers.size();ax++) 
		if (vPlayers[ax].getPVS() ) draw_player_vecs(ax);
}

//==============================================================================
void OriginAimbot::draw_player_vecs(int ax)
{
    // draw history:
	if(cvar.avdraw==2)
	{
		cl_entity_s* ent = vPlayers[ax].getEnt();
		int  historyIndex = ent->current_position;
		for(int i=0;i<HISTORY_MAX;i++)
		{
			gDrawFilledBoxAtLocation(ent->ph[historyIndex].origin,0xFFFFFFFF,1);

			// step back
			--historyIndex; if(historyIndex<0) historyIndex=(HISTORY_MAX-1);
			}
	}

	vec3_t aim_location, target_origin;
	vec3_t up, right, forward, playerAngles;

	vector<aimvec>::iterator pos, end;
	if (vPlayers[ax].getEnt()->curstate.usehull == 0)
	{
			pos = AimVecsS.begin();
			end = AimVecsS.end();
	} else {
			pos = AimVecsD.begin();
			end = AimVecsD.end();
	}


	// get predicted origin
	PredictTarget(ax,target_origin);

	// calculate aiming vectors
	playerAngles[0]=0;
	playerAngles[1]=vPlayers[ax].getEnt()->angles[1];
	playerAngles[2]=0;
	gEngfuncs.pfnAngleVectors (playerAngles, forward, right, up);
	forward[2] = -forward[2];

	register DWORD color = 0xFF1111FF;
	for (;pos!=end;++pos) 
	{
		VectorCopy(target_origin,aim_location);

		aim_location = aim_location + forward * pos->f;
		aim_location = aim_location + up * pos->h;
		aim_location = aim_location + right * pos->r;
		
		gDrawFilledBoxAtLocation(aim_location,color,1);
		color = 0xFFFFFFFF;
	}
}


//====================================================================================
aimvec* OriginAimbot::TargetRegion(int ax)
{
	vec3_t vecEnd, up, right, forward, EntViewOrg,PredOrg, playerAngles;
	PredictTarget(ax,PredOrg);
	
	vector<aimvec>::iterator si, end;
	if (vPlayers[ax].getEnt()->curstate.usehull == 0)
	{
		// loop AimVecsS
		si = AimVecsS.begin(); end = AimVecsS.end();
	} else {
		// loop AimVecsD
		si = AimVecsD.begin(); end = AimVecsD.end();
	}

    // calculate angle vectors
	playerAngles[0]=0;
	playerAngles[1]=vPlayers[ax].getEnt()->angles[1];
	playerAngles[2]=0;
    gEngfuncs.pfnAngleVectors (playerAngles, forward, right, up);
	forward[2] = -forward[2];

	// trace to aim vectors
	for (;si!=end;++si)
	{
		VectorCopy(PredOrg,EntViewOrg);

		EntViewOrg = EntViewOrg + forward * si->f;
		EntViewOrg = EntViewOrg + up * si->h;
        EntViewOrg = EntViewOrg + right * si->r;
		
		if(pathFree(me.pmEyePos,EntViewOrg)) return &(*si);
	}
	return NULL;
}

//==============================================================================
void OriginAimbot::CalcTargetSpot(float *out)
{
	vec3_t vecEnd, up, right, forward, EntViewOrg, playerAngles;
	cl_entity_s* ent = vPlayers[target].getEnt();
	
	// get predicted origin
	PredictTarget(target,out);

	// calculate angle vectors
	playerAngles[0]=0;
	playerAngles[1]=ent->angles[1];
	playerAngles[2]=0;
	gEngfuncs.pfnAngleVectors (playerAngles, forward, right, up);
	
	aimvec* si = TargetRegion(target);

	// calculate h, r, f
	float h=0,r=0,f=0;
	if (si)
	{
		f = si->f;
		h = si->h;
		r = si->r;
	}
	else 
	{
		if (ent->curstate.usehull==0 && AimVecsS.size()>0)
		{
			f = AimVecsS[0].f;
			h = AimVecsS[0].h;
			r = AimVecsS[0].r;
		}
		else
		{
			f = AimVecsD[0].f;
			h = AimVecsD[0].h;
			r = AimVecsD[0].r;
		}
	}
	if( cvar.randmax )
	{
		randomizer.next();
		h += randomizer.h;
		f += randomizer.f;
		r += randomizer.r;
	}

	// add aim vecs. (out=predicted origin)
	out[0] = out[0] + forward[0]*f + up[0]*h + right[0]*r;
	out[1] = out[1] + forward[1]*f + up[1]*h + right[1]*r;
	out[2] = out[2] + forward[2]*f + up[2]*h + right[2]*r;
}

//==============================================================================
void OriginAimbot::CalcVec_MeToTarget(float *view)
{
	float EntViewOrg[3];
	
	CalcTargetSpot(EntViewOrg);
	VectorCopy(EntViewOrg,aim_spot);

	view[0] = EntViewOrg[0] - me.pmEyePos[0];
	view[1] = EntViewOrg[1] - me.pmEyePos[1];
	view[2] = EntViewOrg[2] - me.pmEyePos[2];
}


//==============================================================================
void OriginAimbot::CalcViewAngles()
{
	float vec_to_target[3];
	CalcVec_MeToTarget( vec_to_target);

	VectorAngles(vec_to_target,aim_viewangles);
	aim_viewangles[0] *= -1;

	// aim_viewangles = 0..360 
	if (aim_viewangles[0]>180) aim_viewangles[0]-=360;
	if (aim_viewangles[1]>180) aim_viewangles[1]-=360;
	// aim_viewangles = -180..180 

	if(cvar.smooth!=0.0)
	{
		float diff[3];
		diff[0] = aim_viewangles[0]-me.viewAngles[0];
		diff[1] = aim_viewangles[1]-me.viewAngles[1];
		
		if (diff[0]>180)  diff[0]-=360;
		if (diff[1]>180)  diff[1]-=360;
		if (diff[0]<-180) diff[0]+=360;
		if (diff[1]<-180) diff[1]+=360;

		if     ( diff[0] >  cvar.smooth ) { aim_viewangles[0] = me.viewAngles[0]+cvar.smooth; }
		else if( diff[0] < -cvar.smooth ) { aim_viewangles[0] = me.viewAngles[0]-cvar.smooth; }
		if     ( diff[1] >  cvar.smooth ) { aim_viewangles[1] = me.viewAngles[1]+cvar.smooth; }
		else if( diff[1] < -cvar.smooth ) { aim_viewangles[1] = me.viewAngles[1]-cvar.smooth; }

		if (aim_viewangles[0]>180)  aim_viewangles[0]-=360;
		if (aim_viewangles[1]>180)  aim_viewangles[1]-=360;
		if (aim_viewangles[0]<-180) aim_viewangles[0]+=360;
		if (aim_viewangles[1]<-180) aim_viewangles[1]+=360;
	}
}


//===================================================================================
//===================================================================================
//===================================================================================
//===================================================================================
//===================================================================================
//===================================================================================
class DrawPoints
{
public:
	void aggregate(float* _origin, DWORD _color=0xFFFFFFFF, int _size=1);
	void draw_all ();

protected:
	// scheduled draw points
	struct ScheduledDrawPoint
	{
		ScheduledDrawPoint() : active(false) {}
		vec3_t origin;
		DWORD  color_compiled;
		int    size;
		bool   active;
	};
	enum { MAX_DRAW_POINTS=64 };
	std::vector<ScheduledDrawPoint> vecDrawPoints;//(64);
	int DrawPointsNextIndex;

public:
	DrawPoints() : DrawPointsNextIndex(0), vecDrawPoints(MAX_DRAW_POINTS) {}
};

//===================================================================================
void DrawPoints::aggregate(float* _origin, DWORD _color /*=0xFFFFFFFF*/, int _size /*=1*/ )