#include <hge.h>
#include <hgesprite.h>
#include <hgeparticle.h>
#include <math.h>
#include <mmsystem.h>
#include "Enemy.h" 
//#include "Barrier.h"
#include "Global.h"


TEnemy::CollisionEnemyToBarriers(int EnemyIndex)
{
	for(int i=0; i<100; i++)
	{
		if(Barrier->Bar[i].type != 0)
		{
			if((Alen[EnemyIndex].ttx+16 > Barrier->Bar[i].SensitiveX) && (Alen[EnemyIndex].ttx-16 < Barrier->Bar[i].SensitiveX + Barrier->Bar[i].SensitiveWidth))
			if((Alen[EnemyIndex].tty+16 > Barrier->Bar[i].SensitiveY) && (Alen[EnemyIndex].tty-16 < Barrier->Bar[i].SensitiveY + Barrier->Bar[i].SensitiveHeight))
			{
				if((Alen[EnemyIndex].BackPosX+16 > Barrier->Bar[i].SensitiveX) && (Alen[EnemyIndex].BackPosX-16 < Barrier->Bar[i].SensitiveX + Barrier->Bar[i].SensitiveWidth)) 
				{
					Alen[EnemyIndex].tty = Alen[EnemyIndex].BackPosY;
					if(Alen[EnemyIndex].RoundX == false)
					{
						while(Alen[EnemyIndex].rotation > 360)
							Alen[EnemyIndex].rotation -= 360;
						while(Alen[EnemyIndex].rotation < 0)
							Alen[EnemyIndex].rotation += 360;

						if(Alen[EnemyIndex].rotation > 0 && Alen[EnemyIndex].rotation <= 90)
							Alen[EnemyIndex].angle = 155;
						else if(Alen[EnemyIndex].rotation > 90 && Alen[EnemyIndex].rotation <= 180)
							Alen[EnemyIndex].angle = 65;
						else if(Alen[EnemyIndex].rotation > 180 && Alen[EnemyIndex].rotation <= 270)
							Alen[EnemyIndex].angle = 335;
						else if(Alen[EnemyIndex].rotation > 270 && Alen[EnemyIndex].rotation <= 360)
							Alen[EnemyIndex].angle = 255;

						Alen[EnemyIndex].delta = Alen[EnemyIndex].rotation - Alen[EnemyIndex].angle;

						if((Alen[EnemyIndex].rotation < Alen[EnemyIndex].angle) && (abs(Alen[EnemyIndex].delta) < 180))
							Alen[EnemyIndex].Turn = true;
						else if((Alen[EnemyIndex].rotation < Alen[EnemyIndex].angle) && (abs(Alen[EnemyIndex].delta) > 180))
							Alen[EnemyIndex].Turn = false;
						else if((Alen[EnemyIndex].rotation > Alen[EnemyIndex].angle) && (abs(Alen[EnemyIndex].delta) < 180))
							Alen[EnemyIndex].Turn = false;
						else if((Alen[EnemyIndex].rotation > Alen[EnemyIndex].angle) && (abs(Alen[EnemyIndex].delta) > 180))
							Alen[EnemyIndex].Turn = true;

						Alen[EnemyIndex].delta = abs(Alen[EnemyIndex].delta);
						if(Alen[EnemyIndex].delta > 180)
							Alen[EnemyIndex].delta = 360 - Alen[EnemyIndex].delta;
					}

					Alen[EnemyIndex].RoundX = true;
				}else{
					Alen[EnemyIndex].RoundX = false;
				}
				if((Alen[EnemyIndex].BackPosY+16 > Barrier->Bar[i].SensitiveY) && (Alen[EnemyIndex].BackPosY-16 < Barrier->Bar[i].SensitiveY + Barrier->Bar[i].SensitiveHeight))
				{
					Alen[EnemyIndex].ttx = Alen[EnemyIndex].BackPosX;
					if(Alen[EnemyIndex].RoundY == false)
					{
						while(Alen[i].rotation > 360)
							Alen[i].rotation -= 360;
						while(Alen[i].rotation < 0)
							Alen[i].rotation += 360;

						if(Alen[EnemyIndex].rotation > 0 && Alen[EnemyIndex].rotation <= 90)
							Alen[EnemyIndex].angle = 335;
						else if(Alen[EnemyIndex].rotation > 90 && Alen[EnemyIndex].rotation <= 180)
							Alen[EnemyIndex].angle = 245;
						else if(Alen[EnemyIndex].rotation > 180 && Alen[EnemyIndex].rotation <= 270)
							Alen[EnemyIndex].angle = 155;
						else if(Alen[EnemyIndex].rotation > 270 && Alen[EnemyIndex].rotation <= 360)
							Alen[EnemyIndex].angle = 65;

						Alen[EnemyIndex].delta = Alen[EnemyIndex].rotation - Alen[EnemyIndex].angle;

						if((Alen[EnemyIndex].rotation < Alen[EnemyIndex].angle) && (abs(Alen[EnemyIndex].delta) < 180))
							Alen[EnemyIndex].Turn = true;
						else if((Alen[EnemyIndex].rotation < Alen[EnemyIndex].angle) && (abs(Alen[EnemyIndex].delta) > 180))
							Alen[EnemyIndex].Turn = false;
						else if((Alen[EnemyIndex].rotation > Alen[EnemyIndex].angle) && (abs(Alen[EnemyIndex].delta) < 180))
							Alen[EnemyIndex].Turn = false;
						else if((Alen[EnemyIndex].rotation > Alen[EnemyIndex].angle) && (abs(Alen[EnemyIndex].delta) > 180))
							Alen[EnemyIndex].Turn = true;

						Alen[EnemyIndex].delta = abs(Alen[EnemyIndex].delta);
						if(Alen[EnemyIndex].delta > 180)
							Alen[EnemyIndex].delta = 360 - Alen[EnemyIndex].delta;
					}

					Alen[EnemyIndex].RoundY = true;
				}else{
					Alen[EnemyIndex].RoundY = false;
				}
				if(Alen[EnemyIndex].tty != Alen[EnemyIndex].BackPosY && Alen[EnemyIndex].ttx != Alen[EnemyIndex].BackPosX)
				{
					Alen[EnemyIndex].ttx = Alen[EnemyIndex].BackPosX;
					Alen[EnemyIndex].tty = Alen[EnemyIndex].BackPosY;
				}
			}else{
				Alen[EnemyIndex].RoundX = false;
				Alen[EnemyIndex].RoundY = false;
			}

		}
	}
		
}


TEnemy::TEnemy(HTEXTURE AlenType)
{
	ZeroMemory(Alen, sizeof(Alen));
	MaxAlen = 0;
	TempAngle = 0;

	AlenType = hge->Texture_Load("Alen.png");
	sprAlenType1 = new hgeSprite(AlenType, 0, 0, 32, 32);
	sprAlenType1->SetHotSpot(16, 16);
}

TEnemy::Update(float dt)
{
	for(int i=0; i<MaxAlen; i++)
	{
		if(Alen[i].type!=0)
		{
			if(Alen[i].Death == false)
			{
				
				if((Alen[i].TimeAngle > 1) && (hge->Random_Int(0,4)==0) && Alen[i].RoundX == false && Alen[i].RoundY == false)
				{

					while(Alen[i].rotation > 360)
						Alen[i].rotation -= 360;
					while(Alen[i].rotation < 0)
						Alen[i].rotation += 360;

					FindAngle(i);

					Alen[i].TimeAngle = 0;
					Alen[i].delta = Alen[i].rotation - Alen[i].angle;

					if((Alen[i].rotation < Alen[i].angle) && (abs(Alen[i].delta) < 180))
						Alen[i].Turn = true;
					else if((Alen[i].rotation < Alen[i].angle) && (abs(Alen[i].delta) > 180))
						Alen[i].Turn = false;
					else if((Alen[i].rotation > Alen[i].angle) && (abs(Alen[i].delta) < 180))
						Alen[i].Turn = false;
					else if((Alen[i].rotation > Alen[i].angle) && (abs(Alen[i].delta) > 180))
						Alen[i].Turn = true;

					Alen[i].delta = abs(Alen[i].delta);
					if(Alen[i].delta > 180)
						Alen[i].delta = 360 - Alen[i].delta;
				}

				/*
				if(Alen[i].RoundX == true && Alen[i].RoundY == true) //застрял глубоко в...
				{
				}
				*/
				

				
				if(Alen[i].tty < -32)
					Alen[i].rotation = 215;
				else if(Alen[i].tty > 1420)
					Alen[i].rotation = 30;

				if(Alen[i].ttx < -32)
					Alen[i].rotation = 115;
				else if(Alen[i].ttx > 2040)
					Alen[i].rotation = 300;





				if(Alen[i].Turn == true)
					Alen[i].rotation += Alen[i].delta/20;
				else
					Alen[i].rotation -= Alen[i].delta/20;

				Alen[i].delta = Alen[i].delta - (Alen[i].delta/20);


				Alen[i].BackPosX = Alen[i].ttx;
				Alen[i].BackPosY = Alen[i].tty;

				if(Alen[i].Move==true)
				{
					Alen[i].ttx += sin(Alen[i].rotation*3.1415926535/180)*Alen[i].speed*dt;
					Alen[i].tty -= cos(Alen[i].rotation*3.1415926535/180)*Alen[i].speed*dt;
					Alen[i].TimeMove += dt;
					CollisionEnemyToBarriers(i);
				}

				Alen[i].TimeAngle += dt;
			}
		}
	}
}

TEnemy::Render(float X, float Y)
{
	for(int i=0; i<MaxAlen;i++)
	{
		if(Alen[i].type != 0)
		{
			sprAlenType1->RenderEx(Alen[i].ttx-X, Alen[i].tty-Y, Alen[i].rotation*3.1415926535/180, 1.0, 0);
		}
	}
}

TEnemy::FindAngle(int Index) // находит угол, к котрому стремиться
{
		Alen[Index].angle = (atan2(Alen[Index].ttx - PosX, Alen[Index].tty - PosY)*180/3.1415926535);
		if(Alen[Index].angle>0) Alen[Index].angle = 360 - Alen[Index].angle;
		else Alen[Index].angle *= -1;
		Alen[Index].angle += hge->Random_Float(-90,90); //вносим разнообразие
}

TEnemy::Add(float x, float y)
{
	int Index = -1;

	for(int i=0; i<10000; i++)//ищем пустое место
	{
		if(Alen[i].type==0)
		{
			Index = i;
			break;
		}
	}

	if(Index != -1)//Если нашли место - помещаем туда
	{
		Alen[Index].Attack = false;
		Alen[Index].Death = false;
		Alen[Index].Move = true;
		Alen[Index].RoundX = 0;
		Alen[Index].RoundY = 0;
		Alen[Index].Turn = false;
		Alen[Index].speed = 100;
		Alen[Index].TimeAngle = 0;
		Alen[Index].TimeDeath = 0;
		Alen[Index].TimeMove = 0;
		Alen[Index].ttx = x;
		Alen[Index].tty = y;
		Alen[Index].delta = 0;
		Alen[Index].Health = 100;
		Alen[Index].type = 1;
			

		FindAngle(Index);

		Alen[Index].rotation = (atan2(Alen[Index].ttx - PosX, Alen[Index].tty - PosY)*180/3.1415926535);
		if(Alen[Index].rotation>0) Alen[Index].rotation = 360 - Alen[Index].rotation;
		else Alen[Index].rotation *= -1;

		if(Index == MaxAlen) MaxAlen++; //Больше 1000 не получиться т.к. Index ограничивается в цикле поиска пустого места.
	}
}

TEnemy::Delete(int Index)
{
	Alen[Index].Attack = false;
	Alen[Index].Death = false;
	Alen[Index].Move = false;
	Alen[Index].RoundX = 0;
	Alen[Index].RoundY = 0;
	Alen[Index].Turn = false;
	Alen[Index].speed = 0;
	Alen[Index].TimeAngle = 0;
	Alen[Index].TimeDeath = 0;
	Alen[Index].TimeMove = 0;
	Alen[Index].ttx = 0;
	Alen[Index].tty = 0;
	Alen[Index].type = 0;
	Alen[Index].delta = 0;
	Alen[Index].Health = 0;
	while(Alen[MaxAlen-1].type==0 && MaxAlen > 1)
		MaxAlen--;
	if(MaxAlen==1 && Alen[0].type==0)
		MaxAlen=0;
}


TEnemy::Back(int Index, char Side)
{
	if(Side=='X' || Side=='x')
		Alen[Index].ttx = Alen[Index].BackPosX;
	if(Side=='Y' || Side=='y')
		Alen[Index].tty = Alen[Index].BackPosY;
}

TEnemy::Fre47ght5n16(int Index, int type)
{
	if(type==1)
	{
		Alen[Index].Health -= hge->Random_Int(0,10) + 45;
	}
	if(Alen[Index].Health <= 0)
		Delete(Index);

}