Main.cpp

#define ATTENTION "SHIT TONE OF TRASH CODE INCLUDED, SOME PARTS OF CODE, INCLUDING PROTECTION FROM ANTI-CHEAT WERE REMOVED, FIX IT BY YOURSELF"

/*===========================================================================

  = Crusader ~ 2000-2002 / Panzer ~ ????-2005 / Hardee ~ 2015-2018          =

  ===========================================================================
  = Hard Hook Reborn - CSO / CSN:Z Hack by Hardee ===========================

  = Credits: ================================================================
  - GameDeception and UnknownCheaters tuts (too much names should be there,
	no time to find them all)
  - Jody Redlot for good working no scope code (eventho i reworked it)
  - Jusic, ot dushi bratishka <3
  - All my niggas from vk.com/hardhook, your patience is really amazing
  - Panzer and Crusader, you guys rock!
  ===========================================================================

  = Features: =
  - XQZ Wallhack
  - ESP (Box, Triangles, Lines, Aim Point)
  - Aimbot, Aim Smooth, Aim Height, Aim FOV, Aim Presets, Team Check
  - Chams (2 modes)
  - Removals (No Smoke, No Flash, No Fog, No Scope)
  - Misc (HUD Hack, Zoom Hack, Additional Crosshair)
  - Pretty dope menu, configs support, offsets-independed, hack protection,
	MUCH improved code, a lot of my self-coded functions, logging

  ===========================================================================
  = Undetected against: XignCode3 / BlackCipher2 / HackShield               =
  ===========================================================================

  =========================================================================*/

#define M_PI 3.14159265358979323846					//sorry for mixed russian~english comments, and yes, it's PI
#define _CRT_SECURE_NO_WARNINGS

#include "OpenGL32.h"								//îïåíãë ôóíêöèè
#include "Main.h"									//âñå îñòàëüíûå ôóíêöèè/ïåðåìåííûå
#include "Structs.h"								//ñòðóêòóðû

cvars_s					cvar;						//çíà÷åíèÿ
colors_s				colors;						//öâåòà
keys_s					keys;						//äëÿ óïðàâëåíèÿ êëàâèøàìè
menu_s					menu;						//äëÿ ìåíþ

team_s					team[3];					//âåðòåêñû, êîìàíäû
player_s				player;						//êîîðäèíàòû èãðîêà, âåêòîðû, âûñîòà è ïðî÷åå

inits_s					init;

void sys_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
{
	orig_glMultiTexCoord2fARB(target, s, t);
}

void sys_glActiveTextureARB(GLenum target)
{
	orig_glActiveTextureARB(target);
}

void sys_BindTextureEXT(GLenum target, GLuint texture)
{
	orig_BindTextureEXT(target, texture);
}

void sys_glAlphaFunc(GLenum func, GLclampf ref)
{
	(*orig_glAlphaFunc) (func, ref);
}

void sys_glBegin(GLenum mode)
{
	if (cvar.nofog && bDrawnWorld) {
		(*orig_glDisable)(GL_FOG);
	}

	if ((mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN) && bDrawnWorld) {								//ïèçäàòûé àíäåòåêò âõ + ÷àìñû
		if (cvar.chams) {
			(*orig_glBindTexture)(GL_TEXTURE_2D, 0);
		}
		if (cvar.wallhack && bWall && FoundAnEntity == FALSE) {
			if (!bDrawingEnts) {
				bDrawingEnts = true;																			//ýíòèòè îòðèñîâûâàþòñÿ (÷åðåç ñòåíó)	
				(*orig_glClear)(GL_ACCUM);
			}
		}

		(*orig_glTexEnvi)(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
	}

	if (cvar.nosmoke && bDrawnWorld)																			//nosmoke
	{
		if (mode == GL_QUADS)
		{
			GLfloat smokecol[4];
			(*orig_glGetFloatv)(GL_CURRENT_COLOR, smokecol);
			if ((smokecol[0] == smokecol[1]) && (smokecol[0] == smokecol[2]) && (smokecol[0] != 0.0) && (smokecol[0] != 1.0) && (smokecol[0] >= 0.6) && (smokecol[0] <= 0.7)) { //?
				(*orig_glColor4f)(smokecol[0], smokecol[1], smokecol[2], 0.01);
				bSmoke = true;
			}
			else {
				bSmoke = false;
			}
		}
	}

	if (mode == GL_QUADS && bDrawnWorld)
	{
		if (cvar.noflash)																						//noflash
		{
			GLfloat flashcol[4];
			(*orig_glGetFloatv)(GL_CURRENT_COLOR, flashcol);
			(flashcol[0] == 1.0f && flashcol[1] == 1.0f && flashcol[2] == 1.0f && flashcol[3] > 0.2) ? bFlash = true : bFlash = false;
		}

		if (cvar.hudhack) {																						//hudhack
			float color[4];
			(*orig_glGetFloatv)(GL_CURRENT_COLOR, color);
			bWhite = (color[0] == 1.0f) && (color[1] == 1.0f) && (color[2] == 1.0f) && (color[3] > 0.0f);
			bBlack = (color[0] == 0.0f) && (color[1] == 0.0f) && (color[2] == 0.0f) && (color[3] >= 0.0f);
			if (!(bWhite || bBlack))
				(*orig_glColor4ub)(colors.hudRed, colors.hudGreen, colors.hudBlue, 100);
		}
	}

	if ((mode == GL_POLYGON || mode == GL_QUADS || mode == GL_QUAD_STRIP) && cvar.noscope && bDrawnWorld)		//óëó÷øåííûé noscope îò Æåíè è ìåíÿ
	{
		GLfloat scopecol[4];
		(*orig_glGetFloatv)(GL_CURRENT_COLOR, scopecol);
		if (scopecol[0] == 0.0 && scopecol[1] == 0.0 && scopecol[2] == 0.0)
		{
			(*orig_glEnable)(GL_BLEND);
			(*orig_glBlendFunc)(1, 2), (GL_DEPTH_TEST, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA_SATURATE);
			(*orig_glColor4f)(scopecol[0], scopecol[1], scopecol[2], 0.01f);
		}
	}

	if (cvar.chams == 2 && bDrawnWorld) {																		//ïðîçðà÷íûå ìîäåëüêè
		if (mode == GL_TRIANGLE_STRIP || mode == GL_TRIANGLE_FAN) {
			(*orig_glEnable)(GL_BLEND);
			(*orig_glBlendFunc)(1, 2), (GL_DEPTH_TEST, GL_ONE_MINUS_SRC_ALPHA, GL_SRC_ALPHA_SATURATE);
			//(*orig_glBlendFunc)(GL_ONE, GL_ONE);
		}
	}

	(*orig_glBegin) (mode);
}

void sys_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap)
{
	(*orig_glBitmap) (width, height, xorig, yorig, xmove, ymove, bitmap);
}

void sys_glBlendFunc(GLenum sfactor, GLenum dfactor)
{
	(*orig_glBlendFunc) (sfactor, dfactor);
}

void sys_glClear(GLbitfield mask)
{
	(*orig_glClear)(mask);
}

void sys_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
	(*orig_glClearAccum) (red, green, blue, alpha);
}

void sys_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
	(*orig_glClearColor) (red, green, blue, alpha);
}

void sys_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
	(*orig_glColor3f) (red, green, blue);
}

void sys_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
{
	(*orig_glColor3ub) (red, green, blue);
}

void sys_glColor3ubv(const GLubyte * v)
{
	(*orig_glColor3ubv) (v);
}

void sys_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
	(*orig_glColor4f) (red, green, blue, alpha);
}

void sys_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
	(*orig_glColor4ub) (red, green, blue, alpha);
}

void sys_glCullFace(GLenum mode)
{
	(*orig_glCullFace) (mode);
}

void sys_glDeleteTextures(GLsizei n, const GLuint * textures)
{
	(*orig_glDeleteTextures) (n, textures);
}

void sys_glDepthFunc(GLenum func)
{
	(*orig_glDepthFunc) (func);
}

void sys_glDepthMask(GLboolean flag)
{
	(*orig_glDepthMask) (flag);
}

void sys_glDepthRange(GLclampd zNear, GLclampd zFar)
{
	(*orig_glDepthRange) (zNear, zFar);
}

void sys_glDisable(GLenum cap)
{
	(*orig_glDisable) (cap);
}

void sys_glEnable(GLenum cap)
{
	if (!FirstInit)											    //ïåðâûé èãðîâîé êàäð
	{
		FirstInit = true;

		Utils.BuildFont();									    //çàãðóæàåì òî÷å÷íûé øðèôò
		Utils.UnvalidVertex();									//ñáðàñûâàåì âåðøèíû

		if (ProneFix = 0)
			player_height_min = 0;							    //ôèêñ ïðèñåâøèõ èãðîêîâ äëÿ äîäà íàïðèìåð
		else if (!ProneFix)
			player_height_min = 40;								//ìèíèìàëüíàÿ âûñîòà èãðîêà, ïðè êîòîðîé îí íå ñ÷èòàåòñÿ "ìåðòâûì" /*!ÂÍÈÌÀÍÈÅ!*/

		player_height_max = 120;								//ìàêñèìàëüíî äîïóñòèìàÿ âûñîòà èãðîêà

		Utils.SetVerts();										//çàäà¸ì çíà÷åíèÿ âåðòåêñîâ (àëüòåðíàòèâà - ïðîâåðÿòü â glShadeModel)

		player_vertex_min = Utils.GetVertexMin();			    //ïîëó÷èòü ìèíèìàëüíûé âåðòåêñ
		player_vertex_max = Utils.GetVertexMax();				//ïîëó÷èòü ìàêñèìàëüíûé âåðòåêñ

		Config.LoadSettings();									//ãðóçèì êîíôèã
		(*orig_glGetIntegerv)(GL_VIEWPORT, vp);					//áåð¸ì äëèíó/øèðèíó ýêðàíà
	}

	if (EnableDraw)												//åñëè viewport âûçâàí 5ûé ðàç è ÷èò çàãðóæåí (ôèêñ ôïñ äðîïîâ)
	{
		EnableDraw = false;

		if (menu.active)										//1337 OGL ìåíþ
			Draw.Menu(40, 30);

		if (cvar.crosshair && !bCross && bDrawnWorld) {			//ïðèöåë
			Draw.Crosshair(colors.crossRed, colors.crossGreen, colors.crossBlue, colors.crossAlpha, cvar.crosshairSize, cvar.crosshair);
			bCross = true;
		}

		if (cvar.drawfov && !bFOV && bDrawnWorld) {				//ôîâ äëÿ àèìà
			Draw.Circle(cvar.fov, 1.3f, 250, 250, 250, 100);
			bFOV = true;
		}

		if (cvar.debug)											//ñïèñîê èãðîêîâ (èìÿ (ìîäåëü))
			Draw.PlayersInfo(vp[2] - 320, 30);
	}

	(*orig_glEnable) (cap);
}

void sys_glEnd(void)
{
	(*orig_glEnd) ();
}

void sys_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
	if (cvar.zoomhack && GetAsyncKeyState(keys.zoomkey)) {		//çóìõàê
		if (cvar.zoomfactor > 9)
			cvar.zoomfactor = 9;

		top = zNear * tan((50 - cvar.zoomfactor * 5) * M_PI / 360);
		bottom = -top;
		left = bottom * 4 / 3;
		right = top * 4 / 3;
	}

	(*orig_glFrustum) (left, right, bottom, top, zNear, zFar);
}

void sys_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
	(*orig_glOrtho) (left, right, bottom, top, zNear, zFar);
}

void sys_glPopMatrix(void)
{
	if (cvar.wallhack)			//ñòåíà áûëà îòðèñîâàíà
		bWall = false;

	if (player.get)             //èãðîê áûë îòðèñîâàí
		player.get = false;

	(*orig_glPopMatrix) ();
}

void sys_glPopName(void)
{
	(*orig_glPopName) ();
}

void sys_glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities)
{
	(*orig_glPrioritizeTextures) (n, textures, priorities);
}

void sys_glPushAttrib(GLbitfield mask)
{
	(*orig_glPushAttrib) (mask);
}

void sys_glPushClientAttrib(GLbitfield mask)
{
	(*orig_glPushClientAttrib) (mask);
}

void sys_glPushMatrix(void)
{
	if (cvar.wallhack)
		bWall = true;	 //ðèñóåòñÿ ñòåíà

	(*orig_glPushMatrix) ();
}

void sys_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
	(*orig_glRotatef) (angle, x, y, z);
}

void sys_glShadeModel(GLenum mode)
{
	(*orig_glShadeModel) (mode);

	GLdouble wx, wy, wz, wx2, wy2, wz2, wx3, wy3, wz3;
	GLfloat  color[4];
	(*orig_glGetFloatv)(GL_CURRENT_COLOR, color);

	(*orig_glGetDoublev)(GL_MODELVIEW_MATRIX, mm);
	(*orig_glGetDoublev)(GL_PROJECTION_MATRIX, pm);
	(*orig_glDisable)(GL_TEXTURE_2D);

	//Çäåñü íà÷èíàåòñÿ îòðèñîâêà ìîäåëåé
	if ((mode == GL_SMOOTH) && !(player.get))
	{

		player.get = true;
		player.highest_z = -99999;
		player.lowest_z = -99999;
		player.vertices = 0;

	}
	else {

		if (Utils.isWeapon(player.vertices) != "not a weapon") { /* åñï íà íåêîòîðîå îðóæèå
																	(ñ4, ãðàíàòû, íåêîòîðûå ãèëüçû(äà, ëîë, è íå ôèêñèòñÿ)) */
			gluProject(player.highest_x, player.highest_y, player.highest_z + roffset, mm, pm, vp, &wx, &wy, &wz);
			gluProject(player.lowest_x, player.lowest_y, player.lowest_z, mm, pm, vp, &wx2, &wy2, &wz2);

			float px = (float)(wx / (vp[2] / 2)) - 1;
			float py = (float)(wy / (vp[3] / 2)) - 1;
			float px2 = (float)(wx2 / (vp[2] / 2)) - 1;
			float py2 = (float)(wy2 / (vp[3] / 2)) - 1;

			Draw.WeaponEsp(px, py, px2, py2, player.vertices);
		}

		if (player.get && player.vertices > player_vertex_min && player.height > player_height_min && player.height < player_height_max && player.height < 80)
		{
			if ((player.height > player_height_min) && (player.height < 55))    //èãðîê ñèäèò?
				//roffset = (26.0f - cvar.duck_h)*(-1.0f);						//èñïîëüçóåì îôôñåò, åñëè äà
				roffset = cvar.aimheight_d * (-1.0f);
			else
				//roffset = (24.0f - cvar.stand_h)*(-1.0f);
				roffset = cvar.aimheight_s * (-1.0f);

			gluProject(player.highest_x, player.highest_y, player.highest_z + roffset, mm, pm, vp, &wx, &wy, &wz);
			gluProject(player.lowest_x, player.lowest_y, player.lowest_z, mm, pm, vp, &wx2, &wy2, &wz2);
			gluProject(player.highest_x, player.highest_y, player.highest_z, mm, pm, vp, &wx3, &wy3, &wz3);

			GLfloat rasdist[1]; GLfloat headDist[1]; GLfloat footDist[1];

			(*orig_glRasterPos3f)(player.highest_x, player.highest_y, player.highest_z + roffset);
			(*orig_glGetFloatv)(GL_CURRENT_RASTER_DISTANCE, rasdist);
			player.distance = fabs(rasdist[0]);

			(*orig_glRasterPos3f)(player.highest_x, player.highest_y, player.highest_z);
			(*orig_glGetFloatv)(GL_CURRENT_RASTER_DISTANCE, headDist);
			player.headDistance = fabs(headDist[0]);

			(*orig_glRasterPos3f)(player.lowest_x, player.lowest_y, player.lowest_z);
			(*orig_glGetFloatv)(GL_CURRENT_RASTER_DISTANCE, footDist);
			player.footDistance = fabs(footDist[0]);

			player.cDistance = fabs((player.headDistance + player.footDistance) / 2);

			if (cvar.debug) {									    //îòëàäî÷íîå åñï äëÿ ïîèñêà âåðøèí
				if (player.vertices > vertMin && player.vertices < vertMax) {
					if (player.height < player_height_min) {
						player.dead = true;
					}
					else {
						player.dead = false;
						float px2 = (float)(wx2 / (vp[2] / 2)) - 1;
						float py2 = (float)(wy2 / (vp[3] / 2)) - 1;
						Draw.DebugEsp(px2, py2, player.vertices);
					}
				}
			}

			if (Utils.isPlayer(player.vertices)) {				   //åñëè öåëü - èãðîê
				if (player.height < player_height_min) {           //êîãäà pronefix - 1, âñåãäà ëîæíî
					player.dead = true;
				}
				else {

					player.dead = false;
					float px = (float)(wx / (vp[2] / 2)) - 1;
					float py = (float)(wy / (vp[3] / 2)) - 1;
					float pz = (float)(wz / (vp[2] / 2)) - 1;

					float px2 = (float)(wx2 / (vp[2] / 2)) - 1;
					float py2 = (float)(wy2 / (vp[3] / 2)) - 1;
					float pz2 = (float)(wz2 / (vp[2] / 2)) - 1;

					float px3 = (float)(wx3 / (vp[2] / 2)) - 1;
					float py3 = (float)(wy3 / (vp[3] / 2)) - 1;
					float pz3 = (float)(wz3 / (vp[2] / 2)) - 1;

					Draw.PlayerEsp(px3, py3, pz3, px2, py2, pz2, player.vertices, player.cDistance);
					// ^ ðèñóåì åñï íà èãðîêå, ïåðåäà¸ì â ôóíêöèþ åãî âåðøèíû
					Draw.AimPoint(px, py);							//ðèñóåì òî÷êó, êóäà áóäåò èäòè íàâîäêà
				}
			}

			float delx = ((float)((vp[2] / 2) - (wx)));
			float dely = ((float)((vp[3] / 2) - (vp[3] - wy)));

			float lastx2 = ((vp[2] / 2) - ((player.vector_x * vp[2]) / 65535));
			float lasty2 = ((vp[3] / 2) - (((player.vector_y * vp[3]) / 65535) + vp[3]));

			if (AimAt == -1 && player.height > player_height_min && player.height < player_height_max)
			{
				//íå âêëþ÷àåì â ïîèñê íàøó ìîäåëü
				//åñëè íàøëè êîãî-òî, ïðîâåðÿåì åãî êîìàíäó
				if ((player.vertices < player_vertex_max) && (player.vertices > player_vertex_min) && (player.height < player_height_max) && (wx >= vp[2] / 2 - cvar.fov) && (wx <= vp[2] / 2 + cvar.fov) && (wy >= vp[3] / 2 - cvar.fov) && (wy <= vp[3] / 2 + cvar.fov)) {
					if (Utils.isPlayer(player.vertices)) {
						if (((delx + dely) < (lastx2 + lasty2)) || (player.vector_x + player.vector_y) == 0)
						{
							//ñ÷èòàåì è çàäà¸ì âåêòîðû äâèæåíèÿ ìûøè
							player.vector_x = (float)((wx * 65535) / vp[2]);
							player.vector_y = (float)(((vp[3] - wy) * 65535) / vp[3]);

							TargetX = (float)wx;
							TargetY = (int)vp[3] - (float)wy;
						}

						//ïîçèöèÿ ìîäåëè äëÿ ïðîâåðêè íà âèäèìîñòü
						player.origin_x = player.highest_x;
						player.origin_y = player.highest_y;
						player.origin_z = player.highest_z + roffset;

						if (Utils.isPlayer(player.vertices) && cvar.target == 0) {
							AimAt = 0; //àèì íà ëþáîãî èãðîêà
						}
						else {
							switch (Utils.GetTeam(player.vertices)) {
							case 1:
								if (cvar.target == 1) //tt
									AimAt = 1;
								break;
							case 2:
								if (cvar.target == 2) //ct
									AimAt = 2;
								break;
							case 3:
								if (cvar.target == 3) //zm
									AimAt = 3;
								break;
							}
						}
					}
				}
			}
		}
	}

	(*orig_glEnable)(GL_TEXTURE_2D);
	(*orig_glColor4f)(color[0], color[1], color[2], color[3]);
}

void sys_glTexCoord2f(GLfloat s, GLfloat t)
{
	(*orig_glTexCoord2f) (s, t);
}

void sys_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
{
	(*orig_glTexEnvf) (target, pname, param);
}

void sys_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
{
	(*orig_glTexImage2D) (target, level, internalformat, width, height, border, format, type, pixels);
}

void sys_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
	(*orig_glTexParameterf) (target, pname, param);
}

void sys_glTranslated(GLdouble x, GLdouble y, GLdouble z)
{
	(*orig_glTranslated) (x, y, z);
}

void sys_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
{
	(*orig_glTranslatef) (x, y, z);
}

void sys_glVertex2f(GLfloat x, GLfloat y)
{
	if (bFlash && cvar.noflash && bDrawnWorld)
	{
		if (x == vp[2] && y == vp[3])					//êàê òîëüêî ýêðàí çàëèâàåòñÿ ñïëîøíûì áåëûì öâåòîì (ýôôåêò îò ôëåøêè)
		{
			(*orig_glColor4f)(1.0f, 1.0f, 1.0f, 0.1f);	//çàìåíÿåì åãî íà öâåò ñ î÷åíü ìàëåíüêîé ïðîçðà÷íîñòüþ
			bFlash = false;
		}
		return (*orig_glVertex2f) (x, y);
	}
	else
		return (*orig_glVertex2f) (x, y);
}

void sys_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
{
	if (cvar.chams && player.get && bDrawnWorld) 		//íîâûå ÷àìñû
		(*orig_glColor4ub)(colors.chamsRed, colors.chamsGreen, colors.chamsBlue, 150);

	if (player.get)
	{
		player.vertices++;								//ñ÷èòàåì âñå âåðøèíû
														//èùåì ñàìóþ áîëüøóþ òî÷êó íà ìîäåëè èãðîêà
		if ((z > player.highest_z) || (player.highest_z == -99999))
		{
			player.highest_x = x;
			player.highest_y = y;
			player.highest_z = z;
		}
		//è ñàìóþ ìàëåíüêóþ..
		if ((z < player.lowest_z) || (player.lowest_z == -99999)) {
			player.lowest_x = x;
			player.lowest_y = y;
			player.lowest_z = z;
		}

		player.height = player.highest_z - player.lowest_z;

		(*orig_glEnable)(GL_TEXTURE_2D);
	}

	(*orig_glVertex3f) (x, y, z);
}

void sys_glVertex3fv(const GLfloat * v)
{
	return (*orig_glVertex3fv) (v);

	ModelViewport = true;
	bDrawnWorld = true;									//ìèð îòðèñîâûâàåòñÿ

	if (cvar.chams && player.get && bDrawnWorld) 		//íîâûå ÷àìñû
		(*orig_glColor4ub)(colors.chamsRed, colors.chamsGreen, colors.chamsBlue, 150);

	if (player.get)
	{
		player.vertices++;								//ñ÷èòàåì âñå âåðøèíû
														//èùåì ñàìóþ áîëüøóþ òî÷êó íà ìîäåëè èãðîêà
		if ((v[2] > player.highest_z) || (player.highest_z == -99999))
		{
			player.highest_x = v[0];
			player.highest_y = v[1];
			player.highest_z = v[2];
		}
		//è ñàìóþ ìàëåíüêóþ..
		if ((v[2] < player.lowest_z) || (player.lowest_z == -99999)) {
			player.lowest_x = v[0];
			player.lowest_y = v[1];
			player.lowest_z = v[2];
		}

		player.height = player.highest_z - player.lowest_z;

		(*orig_glEnable)(GL_TEXTURE_2D);
	}

	if (cvar.nosmoke && bSmoke && v[0] != player.highest_x && v[1] != player.highest_y && v[2] != player.highest_z &&
		v[0] != player.lowest_x && v[1] != player.lowest_y && v[2] != player.lowest_z) { //1337 smoke check
		return;
	}

	(*orig_glVertex3fv) (v);
}

void sys_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
	ViewportCount++;
	if (ViewportCount >= 5)
		EnableDraw = true;	//êîãäà viewport âûçâàí 5 ðàç, ðàçðåøàåì îòðèñîâêó òåêñòà è ïðî÷èõ ãðàôè÷åñêèõ ýëåìåíòîâ

	if (ModelViewport)
	{
		//åñëè èãðîê âî âðàæåñêîé êîìàíäå è êàêîé ëèáî èç ìåòîäîâ àèìà âûáðàí..
		if (AimAt == cvar.target && cvar.aimbot && GetAsyncKeyState(VK_MBUTTON) && bDrawnWorld)
		{
			if (cvar.aimsmooth == 0) {
				mouse_event(MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE, player.vector_x, player.vector_y, 0, 0);
			}
			else {
				if (TargetX && TargetY)						//íå ðàáîòàåò ñóê
				{
					POINT Target;
					DWORD ScrX = vp[2] / 2;
					DWORD ScrY = vp[3] / 2;

					if (TargetX > (ScrX)) {					//ñóêà
						Target.x = TargetX - (ScrX);
						Target.x /= cvar.aimsmooth;
						Target.x = +Target.x;
					}

					if (TargetX < (ScrX)) {					//áëÿòü
						Target.x = (ScrX)-TargetX;
						Target.x /= cvar.aimsmooth;
						Target.x = -Target.x;
					}

					if (TargetX == (ScrX)) {				//ðàáîòàé
						Target.x = 0;
					}

					if (TargetY > (ScrY)) {					//íàõóé
						Target.y = TargetY - (ScrY);
						Target.y /= cvar.aimsmooth;
						Target.y = +Target.y;
					}

					if (TargetY < (ScrY)) {					//áëÿòü
						Target.y = (ScrY)-TargetY;
						Target.y /= cvar.aimsmooth;
						Target.y = -Target.y;
					}

					if (TargetY == (ScrY)) {				//ÀÛßÂÎÏÎÏÛËðï
						Target.y = 0;
					}
				}
			}
		}

		if (cvar.rcs > 0 & bDrawnWorld) {
			POINT CurPos;
			if (GetAsyncKeyState(VK_LBUTTON)) {
				GetCursorPos(&CurPos);
				SetCursorPos(CurPos.x, CurPos.y + cvar.rcs);
			}
		}

		//ñáðîñ âñåãî äëÿ ïîäñ÷åòà â ñëåäóþùåì êàäðå
		player.highest_z = -99999;
		player.lowest_z = -99999;
		AimAt = -1;
		player.vector_x = 0;
		player.vector_y = 0;
		player.x = 0; player.y = 0;
	}

	//òóò òîæå ñáðîñ, ïî òîé æå ïðè÷èíå
	ModelViewport = false;
	bCross = false;
	bFOV = false;

	if (EnableDraw) //ïðîâåðÿåì íàæàòû ëè îäíè èç ñëåäóþùèõ êëàâèø åñëè >5ûé viewport (äîâîëüíî áûñòðî)
	{
		Utils.HandleKey(keys.menukey);
		Utils.HandleKey(VK_LEFT);
		Utils.HandleKey(VK_RIGHT);
		Utils.HandleKey(VK_UP);
		Utils.HandleKey(VK_DOWN);
	}

	vp[2] = width;   //êàçàëîñü áû, ïðè÷¸ì çäåñü Óêðàèíà?
	vp[3] = height;	 //è ÷òî Òèòîâ?

	(*orig_glViewport) (x, y, width, height);
}

PROC sys_wglGetProcAddress(LPCSTR ProcName) //õóÿ, ëîë, òóò GetProcAddress õóê âàëÿëñÿ ïîä íîãàìè äâà ãîäà, ðîôë
{											//ñïàñèáî òåáå êðóñàäåð. îò äóøè.
	if (!strcmp(ProcName, "glMultiTexCoord2fARB"))
	{
		orig_glMultiTexCoord2fARB = (func_glMultiTexCoord2fARB_t)orig_wglGetProcAddress(ProcName);
		return (FARPROC)sys_glMultiTexCoord2fARB;
	}
	else if (!strcmp(ProcName, "glBindTextureEXT"))
	{
		orig_BindTextureEXT = (func_BindTextureEXT_t)orig_wglGetProcAddress(ProcName);
		return (FARPROC)sys_BindTextureEXT;
	}
	else if (!strcmp(ProcName, "glActiveTextureARB"))
	{
		orig_glActiveTextureARB = (func_glActiveTextureARB_t)orig_wglGetProcAddress(ProcName);
		return (FARPROC)sys_glActiveTextureARB;
	}
	return orig_wglGetProcAddress(ProcName);
}

void sys_wglSwapBuffers(HDC hDC)
{
	ViewportCount = 0;							//ñáðàñûâàåò êîë-âî âûçîâîâ viewport, òàê êàê ýòî ïîñëåäíÿÿ ôóíêöèÿ â êîíöå êàæäîãî êàäðà
	bDrawnWorld = false;					    //ìèð íå îòðèñîâûâàåòñÿ
	bDrawingEnts = false;						//ýíòèòè íå îòðèñîâûâàþòñÿ

	(*orig_wglSwapBuffers) (hDC);
}

#pragma warning(disable:4100)
BOOL __stdcall DllMain(HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)
{
	switch (fdwReason)
	{
	case DLL_PROCESS_ATTACH:
		DisableThreadLibraryCalls(hOriginalDll);

		hInst = hinstDll;
		return Init();
	case DLL_PROCESS_DETACH:
		if (hOriginalDll != NULL)
		{
			Config.SaveSettings();						   //ñîõðàíÿåì íàñòðîéêè ÷èòà
			Log("[Hooking] Hard Hook Detached. Exit code: %d\r\n", GetLastError());
			FreeLibrary(hOriginalDll);
			hOriginalDll = NULL;
		}
		break;
	}
	return TRUE;
}
#pragma warning(default:4100)


void __cdecl Log(const char* fmt, ...)					  //spasibo
{
	va_list va_alist;
	char logbuf[256] = "";
	FILE* fp;
	SYSTEMTIME SysTime;
	GetLocalTime(&SysTime);

	va_start(va_alist, fmt);
	_vsnprintf(logbuf + strlen(logbuf), sizeof(logbuf) - strlen(logbuf), fmt, va_alist);
	va_end(va_alist);

	if ((fp = fopen("hardhook.log", "ab")) != NULL)		  //îòêðûâàåò ëîã ôàéë, ïèøåò òóäà ñòðîêó ôîðìàòà [Âðåìÿ] Ñîîáùåíèå
	{
		fprintf(fp, "[%02d:%02d:%02d] %s\r\n", SysTime.wHour, SysTime.wMinute, SysTime.wSecond, logbuf);
		fclose(fp);
	}
}