script_enemy_main {

	#include_function ".\..\ShotSheet\shot_replace.dnh"
	#include_function ".\..\functions.txt"
	#include_function ".\..\other\enemy_functions_fairy.txt"

	let GCSD=GetCurrentScriptDirectory;
	let imgEnemy=GPSD~"img\minion.png";

	let type=GetCommonData("E");
	let arg1=GetArgument;
	let arg2=GetCommonData("A2");
	let arg3=GetCommonData("A3");
	let arg4=GetCommonData("A4");
	let arg5=GetCommonData("A5");
	let diff=GetCommonDataDefault("Diff",1);
	let appeared=0;

	let Life=[100,120,1,300,300,150,700,100];
	let expsize=[2,2,1,2,1,1,1,1];
	let expexpand=[0.2,0.3,1,0.2,0.3,0.3,0.5,0.3];
	let bomb=[100,90,0,100,100,100,70,100];

	let size=          [0,3,0,3,5,0,10,3];	//radius of items
	let ScoreItem=     [1,1,0,1,1,1,5,0];
	let MultiplierItem=[0,1,0,1,1,0,3,2];

	let ScoreKill=[3,3,0,5,6,4,10,5]; //divided by 100
	let ScoreDamage=[1.5,1.5,0,2.5,3,3,10,5]; //divided by 100 (Score per kill, but calculated per hit)

	let BeDeleted=1;
	let MaxGraze=0;
	let prevlife=0;
	let totallife=0;
	let ii=0;

	let xs=0;
	let ys=0;

    @Initialize {
	Randomize;
	shotinit;
        SetLife(Life[type]+10000);
	prevlife=Life[type];
	totallife=Life[type];
	DamageRate;

	FairyInit;

	Appear;
    }

    @MainLoop {
	FairyDrawLogic;
	if(type==6&&appeared==1){
		DeathFairyLogic(rand(-20,20)+rand_int(0,1)*180,rand(0,0.8),rand(-20,20)+rand_int(0,1)*18,rand(0,0.8));
	}

	AddScore(((prevlife - (upper(GetLife-10000,0)) )/totallife)*(ScoreDamage[type]*100));
	prevlife=upper(GetLife-10000,0);

	if(appeared==1){
		SetCollisionA(GetX,GetY, 20);
		SetCollisionB(GetX,GetY, 12);
	}

	if((GetX<GetClipMinX-64||GetX>GetClipMaxX+64||GetY<GetClipMinY-64||GetY>GetClipMaxY+64)&&BeDeleted==1){
		VanishEnemy;
	}

	if(GetLife<10000){VanishEnemy;}	

	framee++;

	yield;
    }

task DamageRate{
	let time=GetCommonDataDefault("EnemyInvincibilityA",0);
	SetDamageRate(0,0);
	Wait(time);
	SetDamageRate(215,bomb[type]*2);
}
// Type, X, Y, V, Angle, a1, a2, a3, a4

function Wait(frames){loop(frames){yield;}}




//0=aimed ring	| [type,vel,number],[type,v1,v2,spread,number],frequency,maxtime //------------------------------------------------------------------------------------------------- 

task Move0{
	Shoot0;
	Wait(arg4);
	SetAngle(-90);
	let v=0;
	loop{
		v+=0.02;
		SetSpeed(v);
		yield;
	}
}
task Shoot0{
	if(diff==0){
		arg1[1]=arg1[1]*0.8;
		arg1[2]=arg1[2]*0.5;
	}
	if(diff==1){
		arg1[2]=arg1[2]*0.85;
	}
	if(diff==2){
		arg1[1]=arg1[1]*1.4;
		arg2[2]=arg2[2]*1.4;
	}
	let frame=0;
	ii=0;
	let sounded=true;
	SE("shot2");
	loop(arg1[2]){
		CreateShot01(GetX,GetY,arg1[1],GetAngleToPlayer+ii,arg1[0],0);
		ii+=360/arg1[2];
	}
	if(diff==2){
		ii=(360/arg1[2])/2;
		loop(arg1[2]){
			CreateShot01(GetX,GetY,arg1[1]/2,GetAngleToPlayer+ii,arg1[0],0);
			ii+=360/arg1[2];
		}
	}
	while(frame<arg4&&arg2[4]>0){
		if(sounded==true){
			sounded=false;
		}else{
			SE("shot1");
		}
		ii=0;
		loop(arg2[4]){
			CreateShot01(GetX,GetY,prand(arg2[1],arg2[2]),GetAngleToPlayer+prand(-arg2[3],arg2[3]),arg2[0],0);
		}
		Wait(arg3);
		frame+=arg3;
	}
}


//1=aimed burst	| [type,v1,detonationtime,numlines],[type,v1,v2,number,turntime],frequency,maxtime //-------------------------------------------------------------------------------------------------
task Move1{
	Shoot1;
	Wait(arg4);
	SetAngle(-90);
	let v=0;
	loop{
		v+=0.02;
		SetSpeed(v);
		yield;
	}
}
task Shoot1{
	if(diff==0){
		arg1[2]=round(arg1[2]*0.5);
		arg1[3]=round(arg1[3]*0.5);
		arg2[3]=round(arg2[3]*0.4);
	}
	if(diff==1){
		arg1[2]=round(arg1[2]*0.8);
	}
	let frame=0;
	ii=0;
	let ii2=0;
	while(frame<arg4){
		CreateShotA(0,GetX,GetY,0);
		SetShotDataA(0,0,arg1[1],GetAngleToPlayer,0,0,0,arg1[0]);
		AddShotDelay(0,arg1[2],arg2[0],30);
		SetShotKillTime(0,arg1[2]+1);

		ii2=arg2[1];
		loop(arg2[3]){
			ii=0;
			loop(arg1[3]){
				CreateShotA(1,0,0,0);
				SetShotDataA(1,0,ii2,GetAngleToPlayer+ii,0,(arg2[1]-ii2)/arg2[4],arg2[1],arg2[0]);
				AddShot(arg1[2],0,1,0);
				ii+=360/arg1[3];
			}
			ii2+=(arg2[2]-arg2[1])/arg2[3];
		}
		FireShot(0);

		SE("shot1");
		DelaySound(arg1[2]);
		Wait(arg3);
		frame+=arg3;
	}
}

//2=something //-------------------------------------------------------------------------------------------------
task Move2{
}

//3=spiral | [type,type2,v1,v2,time],[startangle,angleadd],frequency,maxtime //-------------------------------------------------------------------------------------------------  
//unused
task Move3{
	Shoot3;
	Wait(arg4);
	SetAngle(-90);
	let v=0;
	loop{
		v+=0.02;
		SetSpeed(v);
		yield;
	}
}
task Shoot3{
	if(diff==1){
		arg2[1]=arg2[1]*1.5;
		arg3=round(arg3*1.5);
	}
	if(diff==2){
		arg1[3]=arg1[3]*1.3;
	}
	let frame=0;
	let angle=arg2[0];
	let soundtime=0;
	while(frame<arg4){
		if(soundtime<=0){
			SE("shot1");
			soundtime=3;
		}
		CreateShot02(GetX,GetY,arg1[2],angle,(arg1[3]-arg1[2])/arg1[4],arg1[3],arg1[0],0);
		CreateShot02(GetX,GetY,arg1[2],angle+180,(arg1[3]-arg1[2])/arg1[4],arg1[3],arg1[1],0);
		if(diff==2){
			CreateShot02(GetX,GetY,arg1[2]*0.8,angle,(arg1[3]-arg1[2])/arg1[4]*0.8,arg1[3]*0.8,arg1[0],0);
			CreateShot02(GetX,GetY,arg1[2]*0.8,angle+180,(arg1[3]-arg1[2])/arg1[4]*0.8,arg1[3]*0.8,arg1[1],0);
		}
		angle+=arg2[1];
		Wait(arg3);
		soundtime-=arg3;
		frame+=arg3;
	}
}

//4=reflect | [type,vel,baseangle,randomness],[angledifferences],frequency,maxtime //-------------------------------------------------------------------------------------------------  
task Move4{
	Shoot4;
	Wait(arg4);
	Wait(180);
	SetAngle(-90);
	let v=0;
	loop{
		v+=0.01;
		SetSpeed(v);
		yield;
	}
}
task Shoot4{
	if(diff==0){
		arg3*=2;
		arg1[1]=arg1[1]*0.8;
	}
	if(diff==1){
		arg3*=1.5;
	}
	let frame=0;
	let angle=0;
	let currentangle=0;
	while(frame<arg4){
		SE("shot1");

		angle=arg1[2]+arg2[currentangle];
		if(GetPlayerY<GetY){angle=360-angle;}
		ReflectShot(GetX,GetY,arg1[1],angle+rand(-arg1[3],arg1[3]),arg1[0]);

		angle=arg1[2]-arg2[currentangle];
		if(GetPlayerY<GetY){angle=360-angle;}
		ReflectShot(GetX,GetY,arg1[1],angle+rand(-arg1[3],arg1[3]),arg1[0]);

		Wait(arg3);
		currentangle++;
		if(currentangle==length(arg2)){
			currentangle=0;
		}
		frame+=arg3;
	}
}

function ReflectShot(x,y,v,a,g){
	let distance;
	if(cos(a)<0){
		distance=(|x-GetClipMinX|);
	}else{
		distance=(|x-GetClipMaxX|);
	}
	let delay=round((distance/absolute(cos(a)))/v);
	CreateShotA(0,x,y,0);
	SetShotDataA(0,0,v,a,0,0,0,g);
	SetShotDataA(0,delay,v,180-a,0,0,0,g);
	AddShotDelay(0,delay,g,12);
	FireShot(0);

	DelaySound(delay);
}

//5=aimed spread | [type,v,decel,anglespread],[type2,v,accel,anglespread],frequency,maxtime //-------------------------------------------------------------------------------------------------  
task Move5{
	Shoot5;
	Wait(arg4);
	SetAngle(-90);
	let v=0;
	loop{
		v+=0.02;
		SetSpeed(v);
		yield;
	}
}
task Shoot5{
	if(diff==0){
		arg3=round(arg3*2);
		arg2[1]=arg2[1]*0.7;
		arg2[3]=arg2[3]*2;
	}
	if(diff==1){
		arg3=round(arg3*1.5);
		arg2[3]=arg2[3]*0.5;
	}
	let frame=0;
	ii=0;
	let ii2=0;
	let random;
	while(frame<arg4){
		random=rand(-arg2[3],arg2[3]);
		CreateShotA(0,GetX,GetY,0);
		SetShotDataA(0,0,arg1[1],GetAngleToPlayer+rand(-arg1[3],arg1[3]),0,-arg1[1]/arg1[2],0,arg1[0]);
		SetShotDataA(0,arg1[2],0,GetAngleToPlayer+random,0,arg2[1]/arg2[2],arg2[1],arg2[0]);

		CreateShotA(1,0,0,0);
		SetShotDataA(1,0,0,GetAngleToPlayer+random+180,0,arg2[1]/arg2[2],arg2[1],arg2[0]);
		AddShot(arg1[2],0,1,0);

		FireShot(0);
		SE("shot1");
		DelaySound(arg1[2]);
		Wait(arg3);
		frame+=arg3;
	}
}

//6 = death fairy 1 //-------------------------------------------------------------------------------------------------  
task Move6{
	ShakeScreen(3,60);
	SE("shot2");
	SE("crash");
	let angle=0;
	let vd=3;
	let decel=60;
	let va=2.5;
	let accel=60;

	let angleadd1=3;
	let angleadd2=3.5;
	let frequency=6;
	if(diff<=1){
		angleadd1*=1.5;
		angleadd2*=1.5;
		frequency*=1.5;
	}

	let dir=1;
	let i;
	loop(420/frequency){
		i=0;
		loop(4){
			CreateShotA(0,GetX,GetY,0);
			SetShotDataA(0,0,vd,angle+i,0,-vd/decel,0,BLUE21);
			SetShotDataA(0,decel,0,angle+135*dir+i,0,va/accel,va,RED21);
			CreateShotA(1,0,0,0);
			SetShotDataA(1,0,-va,angle+i+90*dir,0,va/accel,va,RED21);
			AddShot(decel,0,1,0);
			FireShot(0);

			if(diff>0){
				CreateShotA(0,GetX,GetY,0);
				SetShotDataA(0,0,vd,-angle+i,0,-vd/decel,0,BLUE21);
				SetShotDataA(0,decel,0,-angle+135*dir+i,0,va/accel,va,GREEN21);
				CreateShotA(1,0,0,0);
				SetShotDataA(1,0,-va,-angle+i+90*dir,0,va/accel,va,GREEN21);
				AddShot(decel,0,1,0);
				FireShot(0);
			}

			i+=90;
		}
		angle+=rand(angleadd1,angleadd2);
		dir=-dir;
		SE("shot1");
		Wait(frequency);
	}
	Wait(120);
	let yspeed=0;
	loop{
		SetY(GetY-yspeed);
		yspeed+=0.015;
		yield;
	}
}

//7 = aimed machinegun [speed,moveangle],[bullet,v1,v2,numangles,anglemod],shots,[accel,maxspeed] //-------------------------------------------------------------------------------------------------

task Move7{
	let speed=arg1[0];
	let moveangle=arg1[1];

	let bullet=arg2[0];
	let v1=arg2[1];
	let v2=arg2[2];
	let numangles=arg2[3];
	let anglemod=arg2[4];

	let shots=arg3;

	let accel=arg4[0];
	let maxspeed=arg4[1];

	if(diff==0){
		arg2[1]=arg2[1]*0.45;
		arg2[2]=arg2[2]*0.45;
	}
	if(diff==1){
		arg2[1]=arg2[1]*0.65;
		arg2[2]=arg2[2]*0.65;
	}

	SetSpeed(speed);
	SetAngle(moveangle);

	let frequency=1;
	if(diff==0){frequency=3;}

	let k=0;
	let soundfreq=0;
	SE("laser4");
	loop(120/frequency){
		k=-(numangles-1)/2;
		loop(numangles){
			CreateShot01(GetX,GetY,rand(v1,v2),GetAngleToPlayer+k*anglemod,bullet,0);
			k++;
		}
		if(soundfreq==0){
			SE("shot2");
			soundfreq=2;
		}else{
			soundfreq--;
		}
		Wait(frequency);
	}
	let vadd=(maxspeed-speed)/accel;
	loop(accel){
		speed+=vadd;
		SetSpeed(speed);
		yield;
	}
}

//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------

    @DrawLoop {
	if(appeared==1){
		if(type==6){
			DeathFairyEffect(10-(1-(GetLife-10000)/700)*6,70);
		}
		FairyDrawLoop;
	}

}
    @Finalize {
	deleteobjects=true;
	yield;
	deleteobjects=false;
	if(GetLife<10000){
		AddScore(ScoreKill[type]*100);

		CreateItems(GetX,GetY,size[type],ScoreItem[type],MultiplierItem[type],arg5[2],arg5[3]);

		SE("enemyexplode");

		CreateExplosion(0,GetX,GetY,expsize[type],[color[0]-prand(0,100),color[1]-prand(0,100),color[2]-prand(0,100)],expexpand[type]);
		CreateExplosion(0,GetX,GetY,expsize[type],[color[0]-prand(0,100),color[1]-prand(0,100),color[2]-prand(0,100)],expexpand[type]/2);

		if(type==6){
			loop(3){
				CreateExplosionEX(3,GetX,GetY,rand(1,5),RainbowArray(rand(-30,30),rand(100,150),100),rand(0.2,0.4),rand(30,60));
				CreateExplosionEX(3,GetX,GetY,rand(1,5),RainbowArray(180+rand(-30,30),rand(100,150),100),rand(0.2,0.4),rand(30,60));
			}
		}
	}
    }


task Appear{
	let angle=GetAngle;
	SetAngle(0);
	let time=GetSpeed;
	SetSpeed(0);
	let distance=3;
	let angleadd=20;
	let actualangle=0;
	let frame=rand_int(0,360);
	let maxtime=time;

//	InwardExplosion(3,GetX,GetY,5,255,time,time/2,2);

	loop(time/5){
		actualangle=angle+sin(frame)*angleadd;
		//CreateExplosionFlat(0,GetX+cos(actualangle)*distance*time,GetY+sin(actualangle)*distance*time,1,color,0.01);
		//AppearEffect(GetX+cos(actualangle)*distance*time,GetY+sin(actualangle)*distance*time,sin(frame)*angleadd,255-(time/maxtime)*255,(),color);
		AppearEffect(GetX+cos(actualangle)*distance*time,GetY+sin(actualangle)*distance*time,255-(time/maxtime)*255,(1-(absolute(maxtime-(time*2))/maxtime))*0.2+0.8,color);
		time-=5;
		frame+=10*(5/3);
		Wait(5);
	}
	CreateExplosionFlat(1,GetX,GetY,1,color,0.3);
	if(type==6){DeathFairyInit(3,5,4);}
	appeared=1;
	if(type==0){Move0;}
	if(type==1){Move1;}
	if(type==2){Move2;}
	if(type==3){Move3;}
	if(type==4){Move4;}
	if(type==5){Move5;}
	if(type==6){Move6;}
	if(type==7){Move7;}
}
	let timer=0;
	let i=0;
	let i2=0;
	let i3=0;
	let framee=0;

let lastx=-100;
let lasty=-100;

task AppearEffect(x,y,alpha,s,color){
	if(lastx==-100){
		lastx=x;
		lasty=y;
	}else{
		let obj=Obj_Create(OBJ_EFFECT);
		Obj_SetPosition(obj,x,y);
		ObjEffect_CreateVertex(obj,4);
		ObjEffect_SetAngle(obj,0,0,atan2(y-lasty,x-lastx)+90);
		ObjEffect_SetLayer(obj,2);

		ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
		ObjEffect_SetTexture(obj,imgEnemy);
		ObjEffect_SetVertexXY(obj,0,-16,-16);
		ObjEffect_SetVertexXY(obj,1, 16,-16);
		ObjEffect_SetVertexXY(obj,2, 16, 16);
		ObjEffect_SetVertexXY(obj,3,-16, 16);
//		ObjEffect_SetVertexUV(obj,0,128,96);
//		ObjEffect_SetVertexUV(obj,1,160,96);
//		ObjEffect_SetVertexUV(obj,2,160,128);
//		ObjEffect_SetVertexUV(obj,3,128,128);
		ObjEffect_SetVertexUV(obj,0,96,64);
		ObjEffect_SetVertexUV(obj,1,128,64);
		ObjEffect_SetVertexUV(obj,2,128,96);
		ObjEffect_SetVertexUV(obj,3,96,96);
		Obj_SetColor(obj,4,alpha,color[0],color[1],color[2]);
		lastx=x;
		lasty=y;
	
		let fulls=s;
		let sadd=s/40;
		loop(40){
			ObjEffect_SetScale(obj,s*3,fulls*3);
			s-=sadd;
			yield;
		}
		Obj_Delete(obj);
	}
}

}
