// GPL License - see http://opensource.org/licenses/gpl-license.php
// Copyright 2006 *nixCoders team - don't forget to credit 
#include "nex.h"
#include <iostream>
#include "phax.h"
CnexAimbot nexAimbot;

typedef enum {
	HITBOX_OFF,
	HITBOX_ETPRO,
	HITBOX_ETMAIN,
	HITBOX_ETPUB_REALHEAD,
	HITBOX_ETPUB_UNFIXED,
	HITBOX_GENERAL,
	
	HITBOX_TOTAL
} hitbox_t;

// for hitbox correction
typedef enum {
	STANDING,
	CROUCH,
	PRONE,

 	MAX_HITBOX_STATE
} HitboxState_t;
typedef struct {
	float x;
	float y;
	float z;
} vec3_union;



vec3_union hitboxDef[HITBOX_TOTAL][MAX_HITBOX_STATE];

void fillHitboxCorrection() {
	hitboxDef[HITBOX_ETPRO][STANDING] = (vec3_union) {-1.0, 0.0, 6.5;};
	hitboxDef[HITBOX_ETPRO][CROUCH] = (vec3_union){-1.0, 0.0, 6.5;};
	hitboxDef[HITBOX_ETPRO][PRONE] = (vec3_union){1.5, -1.0, 6.5;};

	hitboxDef[HITBOX_ETMAIN][STANDING] = (vec3_union){0.0, 0.0, 4.0;};
	hitboxDef[HITBOX_ETMAIN][CROUCH] = (vec3_union){0.0, 0.0, 4.0;};
	hitboxDef[HITBOX_ETMAIN][PRONE] = (vec3_union){0.0, 0.0, 4.0;};

	hitboxDef[HITBOX_ETPUB_REALHEAD][STANDING] = (vec3_union){1.0, -1.0, 6.5;};
	hitboxDef[HITBOX_ETPUB_REALHEAD][CROUCH] = (vec3_union){1.0, -1.0, 6.5;};
	hitboxDef[HITBOX_ETPUB_REALHEAD][PRONE] = (vec3_union){2.0, 0.0, 6.5;};

	hitboxDef[HITBOX_ETPUB_UNFIXED][STANDING] = (vec3_union){0.0, 0.0, 4.0};
	hitboxDef[HITBOX_ETPUB_UNFIXED][CROUCH] = (vec3_union){0.0, 0.0, 4.0};
	hitboxDef[HITBOX_ETPUB_UNFIXED][PRONE] = (vec3_union){0.0, 0.0, 4.0};

	hitboxDef[HITBOX_GENERAL][STANDING] = (vec3_union){0.5, 0.0, 6.5};
	hitboxDef[HITBOX_GENERAL][CROUCH] = (vec3_union){0.5, 0.0, 6.5};
	hitboxDef[HITBOX_GENERAL][PRONE] = (vec3_union){0.5, 0.0, 6.5;};
}
void CnexAimbot::blockMouse(bool state) {
	if (!bot_blockmouse.integer)
		return;

	#define SENSITIVITY_STR "sensitivity"
	static float sensitivity = 0;	// For backup user sensitivity
	static bool mouseBlocked = false;	// Current state
	char buffer[32];

	// Set sensitivity
	if (state && !mouseBlocked) {
		nexSyscall.Cvar_VariableStringBuffer(SENSITIVITY_STR, buffer, sizeof(buffer));
		sensitivity = atof(buffer);

		nexSyscall.SendConsoleCommand(SENSITIVITY_STR " 0\n");
		mouseBlocked = qtrue;
	} else if (!state && mouseBlocked) {
		sprintf_s(buffer, sizeof(buffer), SENSITIVITY_STR " %f\n", sensitivity);
		nexSyscall.SendConsoleCommand(buffer);
		mouseBlocked = false;

	}
					
}







static char *modelBodyTags[] = {
	"tag_chest",
	"tag_torso",
	"tag_bright",
	"tag_lbelt",
	"tag_bleft",
	"tag_ubelt",
	"tag_back",
	"tag_armleft",
	"tag_weapon",
	"tag_armright",
	"tag_weapon2",
	"tag_legright",
	"tag_legleft",
	"tag_footleft",
	"tag_footright"
};
void aimbotUpCommand (void) {}
void CnexAimbot::snapshotPredict( int player ){
	snapPredict_t history[MAX_CLIENTS][3];
	vec3_t va;
	float dt;
	int curTime = orig_syscall( CG_MILLISECONDS );	
	if( (curTime - (int) history[player][0].t)  > 150  || !history[player][1].t || !history[player][2].t ){
		memset( history[player][0].prPos, 0, sizeof(vec3_t));
		return;
	}
	dt = 1000.0 / (history[player][0].t - history[player][1].t);
	va[0] = (history[player][0].trPos[0] - history[player][1].trPos[0])*dt;
	va[1] = (history[player][0].trPos[1] - history[player][1].trPos[1])*dt;
	va[2] = (history[player][0].trPos[2] - history[player][1].trPos[2])*dt;
	history[player][0].prTime = (curTime - history[player][2].t)/333.3;
	VectorCopy(va, history[player][0].prPos );
}


void CnexAimbot::aimAt(vec3_t target) {
	vec3_t org, ang;
	if (bot_enemyprediction.value == 3) {
		vec3_t pVieworg;
		VectorMA(nex.cg_refdef.vieworg, (float)(nex.cg_frametime) / 1000.0f, nex.cg_entities[nex.cg_clientNum].currentState->pos.trDelta, pVieworg);
		VectorSubtract(target, pVieworg, org);
    } else {
		VectorSubtract(target, nex.cg_refdef.vieworg, org);
	}
	vectoangles(org, ang);
	ang[PITCH] -= nex.cg_refdefViewAngles[PITCH];
	ang[YAW] -= nex.cg_refdefViewAngles[YAW];																											
if (bot_human.integer) {
        while (ang[PITCH] < -360.0f)
            ang[PITCH] += 360.0f;
        while (ang[PITCH] > 360.0f)
            ang[PITCH] -= 360.0f;
        while (ang[YAW] < -360.0f)
            ang[YAW] += 360.0f;
        while (ang[YAW] > 360.0f)
            ang[YAW] -= 360.0f;
        if (ang[PITCH] > 180.0f)
            ang[PITCH] -= 360.0f;
        if (ang[PITCH] < -180.0f)
            ang[PITCH] += 360.0f;
        if (ang[YAW] > 180.0f)
            ang[YAW] -= 360.0f;
        if (ang[YAW] < -180.0f)
            ang[YAW] += 360.0f;
    float aimDiv = bot_divmax.value;
        if (aimDiv>(float)(bot_divmin.value)) {
        ang[PITCH] *= bot_humanvalue.value/aimDiv;
        ang[YAW] *= bot_humanvalue.value/aimDiv;
        aimDiv -= bot_humanvalue.value;
        } else
            {
                aimDiv = (float)(bot_divmax.value);
            }
    }
    *(float *)snex.ET->cl_mouseDy += ang[PITCH];
    *(float *)snex.ET->cl_mouseDx += ang[YAW];
}


bool CnexAimbot::getVisibleModelBodyTag(const int player, vec3_t *origin) {
	int count = 0;
	for (; count < (sizeof(modelBodyTags) / sizeof(char *)); count++) {
		char *tagText = modelBodyTags[count];
		orientation_t tagOrientation;
		if (!CG_GetTag(player, tagText, &tagOrientation)) {
			return false;
		}
		if (nexEngine.isVisible(tagOrientation.origin, NULL, NULL )) {
			VectorCopy(tagOrientation.origin, *origin);
			return true;
		}	
	}
	return false;
}

bool CnexAimbot::CG_GetTag(int clientNum, char *tagname, orientation_t *or) {
	nex_centity_t	*cent;
	refEntity_t		*refent;
	vec3_t			tempAxis[3];
	vec3_t			org;
	int				i;
	cent = &nex.cg_entities[clientNum];
	if (!cent->currentValid)
		return false;		
	refent = &nex.cg_entities[clientNum].pe_bodyRefEnt;
	if (nexSyscall.R_LerpTag(or, refent, tagname, 0 ) < 0)
		return false;
	VectorCopy(nex.entities[clientNum].origin, org);
	for (i = 0 ; i < 3 ; i++)
		VectorMA(org, or->origin[i], refent->axis[i], org);
	VectorCopy(org, or->origin);
	MatrixMultiply(refent->axis, or->axis, tempAxis);
	memcpy(or->axis, tempAxis, sizeof(vec3_t) * 3);
	return true;
}
void CnexAimbot::doAutoShoot(bool shoot) {if (bot_auto.integer){
	if (nex.cg_clientNum != nex.cg_snap->ps.clientNum)
		return;
	if (shoot) {
		if (((nex.cg_entities[nex.cg_clientNum].currentState->weapon == WP_K43_SCOPE) || (nex.cg_entities[nex.cg_clientNum].currentState->weapon == WP_GARAND_SCOPE)) && !BG_PlayerMounted(nex.cg_snap->ps.eFlags)) {
			static int lastShootTime = 0;
			if ((nex.cg_time - lastShootTime) >= bot_sniperdelay.value) {
				nexSyscall.SendConsoleCommand("+attack\n");
				lastShootTime = nex.cg_time;
			} else {
				nexSyscall.SendConsoleCommand("-attack\n");
			}
		} else if (bot_burst.integer && (nex.cg_snap->ps.curWeapHeat > bot_burstlimit.value)) {
			nexSyscall.SendConsoleCommand("-attack\n");
		} else {
			nexSyscall.SendConsoleCommand("+attack\n");
		}
	} else {
		nexSyscall.SendConsoleCommand("-attack\n");
	}
}}


int CnexAimbot::findNearestTarget(int targetFlag) {
	int nearest = -1;
	int maxEntities = MAX_GENTITIES;
	if (targetFlag & TARGET_PLAYER)
		maxEntities = MAX_CLIENTS;
	int entityNum = 0;
	if( (bot_priority.value == 1 ) ){
		int ent = nex.cg_snap->ps.persistant[PERS_ATTACKER];
		if( ent && ent <= MAX_CLIENTS ){
			if( ((targetFlag & TARGET_ENEMY) && (targetFlag & TARGET_PLAYER) && IS_PLAYER_ENEMY(entityNum))
				&& nex.entities[ent].isVisible && !IS_PLAYER_DEAD(ent) )
				return ent;
		}
	}
	for (; entityNum < MAX_CLIENTS; entityNum++) {
		nexEntity_t* entity = &nex.entities[entityNum];
		if (!nex.cg_entities[entityNum].currentValid || (entityNum == nex.cg_snap->ps.clientNum) || !nex.client[entityNum].infoValid)
			continue;
		if ((targetFlag & TARGET_PLAYER) && !IS_PLAYER_VALID(entityNum))
			continue;
		if ((targetFlag & TARGET_PLAYER_VULN) && !IS_PLAYER_VULNERABLE(entityNum))
			continue;
		if ((targetFlag & TARGET_PLAYER_ALIVE) && IS_PLAYER_DEAD(entityNum))
			continue;
		if ((targetFlag & TARGET_PLAYER_DEAD) && !IS_PLAYER_DEAD(entityNum))
			continue;
		if ((targetFlag & TARGET_PLAYER_HEAD) && !entity->isHeadVisible)
			continue;
		if ((targetFlag & TARGET_PLAYER_BODY) && VectorCompare(entity->bodyPart, vec3_origin))
			continue;
		if ( (targetFlag & TARGET_VISIBLE) && entity->isVisible &&
			(bot_priority.value==2) && nex.clAttack[entityNum] )
			return entityNum;
		if ((targetFlag & TARGET_ENEMY) && !IS_PLAYER_ENEMY(entityNum))
			continue;
		if ((targetFlag & TARGET_FRIEND) && IS_PLAYER_ENEMY(entityNum))
			continue;
		if ((targetFlag & TARGET_VISIBLE) && !entity->isVisible)
			continue;
		if ((targetFlag & TARGET_NOTVISIBLE) && entity->isVisible)
			continue;
		if( (bot_priority.value == 3) && IS_PANZER(entityNum) )
			return entityNum;
		if( (bot_priority.value == 4) && IS_MG42(entityNum) )
			return entityNum;
		if( (bot_priority.value == 5) && IS_HEAVYWP(entityNum) )
			return entityNum;
		float aimfov = AngleNormalize360(bot_fov.value);
		if (aimfov) {
			vec3_t aimPoint, ang, org;
			if (nex.entities[entityNum].isHeadVisible)
				VectorCopy(nex.entities[entityNum].head, aimPoint);
			else if (!bot_headaim.integer)
				VectorCopy(nex.entities[entityNum].bodyPart, aimPoint);
			else {
				return -1;
			}
			VectorSubtract(aimPoint, nex.cg_refdef.vieworg, org);
			vectoangles(org, ang);
			ang[PITCH] -= nex.cg_refdefViewAngles[PITCH];
			ang[YAW] -= nex.cg_refdefViewAngles[YAW];
			if (ang[PITCH] < 0.0)
				ang[PITCH] *= -1.0;
			if (ang[YAW] < 0.0)
				ang[YAW] *= -1.0;
			if (ang[PITCH] > 360.0f)
				ang[PITCH] -= 360.0f;
			if (ang[YAW] > 360.0f)
				ang[YAW] -= 360.0f;
			float aimFov[2];
		aimFov[0] = (ang[PITCH] - 360.0) * -1.0;
			aimFov[1] = (ang[YAW] - 360.0) * -1.0;
			if (ang[PITCH] > aimFov[0])
				ang[PITCH] = aimFov[0];
			if (ang[YAW] > aimFov[1])
				ang[YAW] = aimFov[1];
			if ((ang[PITCH] > aimfov) || (ang[YAW] > aimfov))
				continue;
		}
		if ((entity->distance != 0)
				&& (nearest == -1 || (entity->distance < nex.entities[nearest].distance))) {
			nearest = entityNum;
		}
	}
	return nearest;
}
void CnexAimbot::doAimbot() {
	bool autoShootWeapon = false;
	int targetFlag[2] = { -1, -1 };
	if (BG_PlayerMounted(nex.cg_snap->ps.eFlags) || (nex.cg_snap->ps.weapon == WP_MOBILE_MG42) || (nex.cg_snap->ps.weapon == WP_MOBILE_MG42_SET)) {
		autoShootWeapon = true;
		targetFlag[0] = TARGET_PLAYER_ENEMY | TARGET_PLAYER_BODY;
			if (!bot_aimdead.integer)
				targetFlag[0] |= TARGET_PLAYER_ALIVE;
		targetFlag[1] = targetFlag[0] | TARGET_PLAYER_HEAD;
	} else {
		switch (nex.cg_snap->ps.weapon) {
			case WP_LUGER:
			case WP_SILENCER:
			case WP_AKIMBO_LUGER:
			case WP_AKIMBO_SILENCEDLUGER:
			case WP_COLT:
			case WP_SILENCED_COLT:
			case WP_AKIMBO_COLT:
			case WP_AKIMBO_SILENCEDCOLT:
			case WP_MP40:
			case WP_THOMPSON:
			case WP_GARAND:
			case WP_K43:
			case WP_FG42:
			case WP_STEN:
			case WP_CARBINE:
			case WP_KAR98:
				autoShootWeapon = true;
				targetFlag[0] = TARGET_PLAYER_ENEMY;
					if (!bot_aimdead.integer)
				targetFlag[0] |= TARGET_PLAYER_ALIVE;
					if (bot_headaim.value == 1) {
						targetFlag[0] |= TARGET_PLAYER_HEAD_BODY;
					} else if (bot_headaim.value == 2) {
						targetFlag[0] |= TARGET_PLAYER_HEAD;
					} else if (bot_headaim.value == 3) {
						targetFlag[1] = targetFlag[0] | TARGET_PLAYER_BODY;
						targetFlag[0] |= TARGET_PLAYER_HEAD;
					} else if (bot_headaim.value == 4) {
						targetFlag[0] |= TARGET_PLAYER_BODY;
					}
					break;
				break;
			case WP_GPG40:
			case WP_M7:
				autoShootWeapon = true;
				targetFlag[0] = TARGET_PLAYER_ENEMY | TARGET_PLAYER_ALIVE | TARGET_PLAYER_BODY;
				break;
			case WP_GARAND_SCOPE:
			case WP_K43_SCOPE:
			case WP_FG42SCOPE:
				autoShootWeapon = true;
				targetFlag[0] = TARGET_PLAYER_ENEMY | TARGET_PLAYER_ALIVE | TARGET_PLAYER_HEAD;
				break;
			case WP_KNIFE:
				targetFlag[0] = TARGET_PLAYER_ENEMY | TARGET_PLAYER_ALIVE | TARGET_PLAYER_HEAD;
				targetFlag[1] = TARGET_PLAYER_ENEMY | TARGET_PLAYER_DEAD | TARGET_PLAYER_HEAD;
				break;
			default:
				break;
		}
	}
	targetFlag[0] |= TARGET_PLAYER_ALIVE;
	if ((bot_auto.integer||GetAsyncKeyState(VK_RBUTTON))
			&& (targetFlag[0] != -1) && (nex.cg_snap->ps.clientNum == nex.cg_clientNum)) {
		int count = 0;
		int target;
		for (; count < (sizeof(targetFlag) / sizeof(int)); count++) {
			if (targetFlag[count] != -1) {
				vec3_t aimPoint;
				VectorCopy(vec3_origin, aimPoint);
				target = findNearestTarget(targetFlag[count]);
				if (target == -1)
					continue;
					if( bot_entcam.value == 3 )
					nex.entCamTarget = target;
				
				// Target found
				if (targetFlag[count] & TARGET_PLAYER) {
					if (targetFlag[count] & TARGET_PLAYER_HEAD) {
						VectorCopy(nex.entities[target].head, aimPoint);
					} else if (targetFlag[count] & TARGET_PLAYER_BODY) {
						VectorCopy(nex.entities[target].bodyPart, aimPoint);
					} else if (targetFlag[count] & TARGET_PLAYER_HEAD_BODY) {
						// Head or body ?
						if (nex.entities[target].isHeadVisible)
							VectorCopy(nex.entities[target].head, aimPoint);
						else
							VectorCopy(nex.entities[target].bodyPart, aimPoint);
					} else {

					}
				} else if (targetFlag[count] & TARGET_MISSILE) {
					VectorCopy(nex.entities[target].origin, aimPoint);
				} else {
				}
				
				// If aim point is set, aim and shoot
				if (!VectorCompare(aimPoint, vec3_origin)) {
					if (!bot_human.integer)
					    doAutoShoot(true);
						aimAt(aimPoint);
					blockMouse(true);

					return;
				}
			}
		}
	blockMouse(false);
	}
	doAutoShoot(nexSyscall.isKeyActionDown("+attack"));
}
void CnexAimbot::doVecZ(int player) {
	nexEntity_t *entity = &nex.entities[player];
	if (!IS_PLAYER_ENEMY(player))
		return;
	switch (nex.cg_snap->ps.weapon) {
		case WP_LUGER:
		case WP_SILENCER:
		case WP_AKIMBO_LUGER:
		case WP_AKIMBO_SILENCEDLUGER:
		case WP_COLT:
		case WP_SILENCED_COLT:
		case WP_AKIMBO_COLT:
		case WP_AKIMBO_SILENCEDCOLT:
		case WP_MP40:
		case WP_THOMPSON:
	 	case WP_MOBILE_MG42:
		case WP_GARAND:
		case WP_K43:
		case WP_FG42:
		case WP_STEN:
		case WP_CARBINE:
		case WP_KAR98:
		case WP_GARAND_SCOPE:
		case WP_K43_SCOPE:
		case WP_FG42SCOPE:
					if (bot_hitbox.integer) {
					vec3_t rmin;
					vec3_t rmax;
					VectorCopy(entity->rmin,rmin);
					VectorCopy(entity->rmax,rmax);
					entity->head[0]=entity->head[0]+(rmin[0]+rmax[0])*0.5f;
					entity->head[1]=entity->head[1]+(rmin[1]+rmax[1])*0.5f;
					entity->head[2]=entity->head[2]+(rmin[2]+rmax[2])*0.5f;}
			if (bot_vecauto.integer) {
				#define NEAR_TARGET_VECZ 5.6f
				if (nex.cg_snap->ps.weapon == WP_GARAND_SCOPE || nex.cg_snap->ps.weapon == WP_K43_SCOPE || nex.cg_snap->ps.weapon == WP_FG42SCOPE) {
					VectorMA(entity->head, NEAR_TARGET_VECZ, entity->headAxis[2], entity->head);
					break;
				}
				int nearTarget;
				if (nex.cg_snap->ps.weapon == WP_STEN)
					nearTarget = 700.0f;
				else
					nearTarget = 500.0f;
				if (entity->distance <= nearTarget)
					VectorMA(entity->head, NEAR_TARGET_VECZ, entity->headAxis[2], entity->head);
				else if ((entity->distance > nearTarget) && (entity->distance < 2000.0f))
					VectorMA(entity->head, (NEAR_TARGET_VECZ * (100.0f - ((entity->distance - nearTarget) / 15.0f))) / 100.0f, entity->headAxis[2], entity->head);
			} else {
					switch (nex.cg_snap->ps.weapon) {
						case WP_STEN:
							VectorMA(entity->head, bot_vecz.value, entity->headAxis[2], entity->head);
							break;
						case WP_K43_SCOPE:
						case WP_GARAND_SCOPE:
						case WP_FG42SCOPE:
							VectorMA(entity->head, bot_scopedvecz.value, entity->headAxis[2], entity->head);
							break;
						default:
							VectorMA(entity->head, bot_vecz.value, entity->headAxis[2], entity->head);
							break;
					}
			}
			break;
		default:
			break;
	}
}
void CnexAimbot::doPrediction(int player) {
		snapPredict_t history[MAX_CLIENTS][3];
	if (!bot_enemyprediction.integer)		return;
	
	nexEntity_t *entity = &nex.entities[player];
	if (bot_enemyprediction.value == 1) {
		VectorMA(entity->origin, (float)(nex.cg_frametime) / 1000.0f, nex.cg_entities[player].currentState->pos.trDelta, entity->origin);
		VectorMA (entity->head, nex.cg_snap->ping / 800, nex.cg_entities[player].currentState->pos.trDelta, entity->head);
	} else if (bot_enemyprediction.value == 2) {
		vec3_t velocity;
		VectorScale(nex.cg_entities[player].currentState->pos.trDelta, 1000.0f / ((float)(nex.cg_frametime) - nex.cg_entities[player].currentState->pos.trTime) , velocity);
		VectorMA(entity->origin, (float)(nex.cg_frametime) / 1000.0f, velocity, entity->origin);
		VectorMA(entity->head, (float)(nex.cg_frametime) / 1000.0f, velocity, entity->head);
	} else if (bot_enemyprediction.value == 4) {
	    VectorMA(entity->origin,  (nex.myping/2) * 0.001f, nex.cg_entities[player].currentState->pos.trDelta, entity->origin);
		VectorMA(entity->head, (nex.myping/2)  * 0.001f, nex.cg_entities[player].currentState->pos.trDelta, entity->head);
	} else if (bot_enemyprediction.value == 5 ) {
		snapshotPredict(player);
		VectorMA(entity->origin,  (nex.myping/2) * 0.001f, history[player][0].prPos, entity->origin);
		VectorMA(entity->head, (nex.myping/2)  * 0.001f, history[player][0].prPos, entity->head);
	} 
}
qboolean isAimbotWeapon(int weapon){
	switch( weapon ){
		case WP_LUGER:
		case WP_MP40:
		case WP_GRENADE_LAUNCHER:
		case WP_PANZERFAUST:
		case WP_COLT:
		case WP_THOMPSON:
		case WP_GRENADE_PINEAPPLE:
		case WP_STEN:
		case WP_SILENCER:
		case WP_KAR98:
		case WP_CARBINE:
		case WP_GARAND:
		case WP_MOBILE_MG42:
		case WP_K43:
		case WP_FG42:
		case WP_DUMMY_MG42:
		case WP_AKIMBO_COLT:
		case WP_AKIMBO_LUGER:
		case WP_SILENCED_COLT:
		case WP_GARAND_SCOPE:
		case WP_K43_SCOPE:
		case WP_FG42SCOPE:
		case WP_AKIMBO_SILENCEDCOLT:
		case WP_AKIMBO_SILENCEDLUGER:
		case WP_MOBILE_MG42_SET:
			return qtrue;
		default:
			return qfalse;
	}
	return qfalse;
}