script_enemy_main {

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

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

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

	let Life=[400,400,500,250,55,2.2, 400,30000];	//divided among the segments
	let expsize=[1,1,2,1.5,1,4,1.2,1];
	let expexpand=[0.4,0.4,0.9,0.4,0.4,2,0.4,0.4];
	let bomb=[100,100,80,100,100,30,50,0];

	let size=          [10,10,0];
	let ScoreItem=     [0, 0, 5,3,1,6,3,0];
	let MultiplierItem=[3, 3, 0];

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

	let cred=  	[150,	255,	255,	100,	255,	128,	255,0];
	let cgreen=	[255,	180,	100,	100,	255,	255,	255,0];
	let cblue= 	[255,	180,	230,	255,	255,	128,	200,0];

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

	let xs=0;
	let ys=0;
	let enemynum=0;

	let initspeed=GetSpeed;

    @Initialize {
	Randomize;
	shotinit;
	enemynum=(rot*E2Num)/360;
        SetLife((Life[type]/(E2Num/2))+10000);
	prevlife=Life[type]/(E2Num/2);
	totallife=Life[type]/(E2Num/2);
	SetDamageRate(230,bomb[type]*1.2);
	SetInvincibility(60);

	if(type==0){Move0;Shoot0;}
	if(type==1){Move1;Shoot1;}
	if(type==2){Move2;Shoot2;}

    }

	let timer=0;
	let i=0;
	let i2=0;
	let i3=0;
	let width=30;
	let rotspeed=3;
	let x=0;
	let y=0;
	let x2=GetX;
	let y2=GetY;

    @MainLoop {
	SetX(x2);
	SetY(y2);
	DrawLogic;
//	DamageGFX(15);
	AddScore(((prevlife - (upper(GetLife-10000,0)) )/totallife)*(ScoreDamage[type]*100));
	prevlife=upper(GetLife-10000,0);
	rot+=rotspeed;

	x=GetX+cos(rot)*width;
	y=GetY+sin(rot)*width;

	SetCollisionA(x, y, 20);
	SetCollisionB(x, y, 15);


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

	if(GetLife<10000){VanishEnemy;}	

	yield;
	x2=GetX+cos(GetAngle)*initspeed;
	y2=GetY+sin(GetAngle)*initspeed;
	SetX(x);
	SetY(y);
    }
// Type, X, Y, V, Angle, a1, a2, a3, a4

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

//-------------------------------------------------------------------------------------------------  //0=aimed lasers	| time1,[rotspeed1,rotspeed2,size1,size2],[vel,length,width,delay],[types]
task Move0{
	arg3[1]=arg3[1]*((diff/6)+0.75);
	arg3[2]=arg3[2]*((diff/6)+0.75);
	rotspeed=arg2[0];
	width=arg2[2];
	let rotadd=(arg2[1]-arg2[0])/arg1;
	let widthadd=(arg2[3]-arg2[2])/arg1;
	loop(arg1){
		rotspeed+=rotadd;
		width+=widthadd;
		yield;
	}
}
task Shoot0{
	Wait(arg1/2);
	loop{
		CreateLaser01(x, y,arg3[0],GetAngleToPlayer,arg3[1],arg3[2],arg4[0][enemynum],0);
		SE("shot3");
		Wait(arg3[3]);
	}
}

//-------------------------------------------------------------------------------------------------  //1=spread lasers	| time,[rotspeed1,rotspeed2,size1,size2],[vel,length,width,delay],[types]
let direction=1;
task Move1{
	arg3[1]=arg3[1]*((diff/6)+0.75);
	arg3[2]=arg3[2]*((diff/6)+0.75);
	if(arg2[0]<0){direction=-1;}
	rotspeed=arg2[0];
	width=arg2[2];
	let rotadd=(arg2[1]-arg2[0])/arg1;
	let widthadd=(arg2[3]-arg2[2])/arg1;
	loop(arg1){
		rotspeed+=rotadd;
		width+=widthadd;
		yield;
	}
}
task Shoot1{
	Wait(arg1/3);
	let k=0;
	loop{
		k+=((rotspeed/arg2[1]));
		if(k>=arg3[3]){CreateLaser01(x,y,arg3[0],atan2(y-GetY,x-GetX)-90*direction,arg3[1],arg3[2],arg4[0][enemynum],0);SE("shot3");k-=arg3[3];}
		yield;
	}
}

//-------------------------------------------------------------------------------------------------  //2=surround	| [time1,time2],[rotspeed1,rotspeed2,size1,size2],[vel,delay],[types]
task Move2{
	SetSpeed(0);
	UpdateSize;
	loop(arg1[1]){
		xs=-((center(-50,GetX-GetPlayerX,50))/20);
		ys=-((center(-50,GetY-GetPlayerY,50))/20);

		SetX(GetX+xs);
		SetY(GetY+ys);
		yield;
	}

	while(x>GetClipMinX-10&&x<GetClipMaxX+10&&y>GetClipMinY-10&&y<GetClipMaxY+10){
		width=width*1.01;
		yield;
	}
	VanishEnemy;
}
task UpdateSize{
	SetLife(20000);
	rotspeed=arg2[0];
	width=arg2[2];
	let rotadd=(arg2[1]-arg2[0])/arg1[0];
	let widthadd=(arg2[3]-arg2[2])/arg1[0];
	loop(arg1[0]){
		rotspeed+=rotadd;
		width+=widthadd;
		yield;
	}
        SetLife((Life[type]/(E2Num/2))+10000);
}
task Shoot2{
	Wait(arg1[0]);
	loop((arg1[1]-arg1[0])/(arg3[1])){

		CreateShotA(1,x,y,0);
		SetShotDataA(1,0,arg3[0],atan2(GetY-y,GetX-x),0,0,0,arg4[0][enemynum*2]);
		SetShotKillTime(1,(distance(GetX,GetY,x,y)^0.5)/arg3[0]);
		FireShot(1);

		DelayEffect(x,y,arg4[0][enemynum*2],20);

		DelayExplosion(GetX,GetY,arg3[0],atan2(GetY-y,GetX-x),arg4[0][(enemynum*2)+1],(distance(GetX,GetY,x,y)^0.5)/arg3[0]);
		Wait(arg3[1]);
	}
}

task DelayExplosion(xx,yy,v,angle,graphic,delay){
	Wait(delay);

	let loopcount=0;
	let anglemod=0;
	loop(8){
		anglemod=prand(6,12);
		CreateShotA(2,xx,yy,0);
		SetShotDataA(2,0,prand(v/2,v*2),angle+loopcount*45,anglemod*RandDir,0,0,graphic);
		SetShotDataA(2,0,prand(v/2,v*2),angle+loopcount*45,0,0,0,graphic);
		SetShotKillTime(2,360/anglemod);
		FireShot(2);
		loopcount++;
	}

	CreateExplosion(0,xx,yy,prand(0.5,2),[prand(100,255),prand(100,255),prand(100,255)],prand(0.2,0.3));

}

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



task Charge(cdelay, cframes, csize, cr,cg,cb, crot) {

    loop(cdelay){yield;}

    let obj = Obj_Create(OBJ_EFFECT);
    let timer=0;
    let spin=prand(0,360);
    let maxcframes=cframes;
    let maxcsize=csize;
    let calpha=0;

    // initial settings    

    Obj_SetPosition   (obj, GetX,GetY);
    Obj_SetSpeed      (obj, 500);
    Obj_SetAngle(obj, 0);
    ObjEffect_SetTexture(obj,imgEnemy);
    ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
    ObjEffect_SetScale(obj,csize,csize);
    ObjEffect_SetAngle(obj,0,0,spin);
    ObjEffect_SetLayer(obj,1);
    ObjEffect_CreateVertex(obj,4);
    ObjEffect_SetVertexXY(obj,0,0-16,0-16);
    ObjEffect_SetVertexXY(obj,1,0-16,0+16);
    ObjEffect_SetVertexXY(obj,2,0+16,0+16);
    ObjEffect_SetVertexXY(obj,3,0+16,0-16);
    ObjEffect_SetVertexUV(obj, 0, 65, 1);
    ObjEffect_SetVertexUV(obj, 1, 65, 63);
    ObjEffect_SetVertexUV(obj, 2, 127, 63);
    ObjEffect_SetVertexUV(obj, 3, 127, 1);
//    Obj_SetAutoDelete(obj,false);


    while(! Obj_BeDeleted(obj)&&cframes>0) {

	Obj_SetX(obj,GetX-500);
	Obj_SetY(obj,GetY);
	ObjEffect_SetAngle(obj,0,0,spin);
	csize=(cframes/maxcframes)*maxcsize;
	ObjEffect_SetScale(obj,csize,csize);
	spin+=crot;
	cframes--;
	if(calpha<200){calpha+=10;}
	ObjEffect_SetVertexColor(obj, 0, calpha, cr,cg,cb);
	ObjEffect_SetVertexColor(obj, 1, calpha, cr,cg,cb);
	ObjEffect_SetVertexColor(obj, 2, calpha, cr,cg,cb);
	ObjEffect_SetVertexColor(obj, 3, calpha, cr,cg,cb);

        yield;

    }
    Obj_Delete(obj);
}


    sub DrawLogic{
	let k=0;
	loop(3){
		ringrot1[k]=ringrot1[k]+ringrotspeed1[k];
		ringrot2[k]=ringrot2[k]+ringrotspeed2[k];
		ringrot3[k]=ringrot3[k]+ringrotspeed3[k];
		k++;
	}
    }




	let ringrot1=[RA,RA,RA];
	let ringrot2=[RA,RA,RA];
	let ringrot3=[RA,RA,RA];
	let ringrotspeed1=[RA2,RA2,RA2];
	let ringrotspeed2=[RA2,RA2,RA2];
	let ringrotspeed3=[RA2,RA2,RA2];

	function RA{return rand(0,360);}
	function RA2{return rand(-5,5);}


    let cred=  [255,255,255,150,150,150,255];
    let cgreen=[150,200,255,255,255,150,150];
    let cblue= [150,150,180,150,255,255,255];


    @DrawLoop {
        SetTexture(imgEnemy);

	SetColor(cred[arg4[1][enemynum]],cgreen[arg4[1][enemynum]],cblue[arg4[1][enemynum]]);

	SetGraphicRect(32, 64, 80, 112);
	let k=0;
	loop(3){
		SetAlpha(200-k*60);
		SetGraphicScale(1+k/3,1+k/3);
		SetGraphicAngle(ringrot1[k],ringrot2[k],ringrot3[k]);
		DrawGraphic(x, y);
		k++;
	}

        SetGraphicRect(0, 64, 32, 96);
	SetGraphicAngle(0,0,-rot);
	SetGraphicScale(1,1);
	SetAlpha(255);
	DrawGraphic(x, y);
}

    @Finalize {
	if(GetLife<10000){
		SetX(x);
		SetY(y);
		AddScore(ScoreKill[type]*100);

		CreateItems(GetX,GetY,size[type],ScoreItem[type],MultiplierItem[type],arg5[0],arg5[1]);

		SE("enemyexplode");
//		CreateExplosion(GetX,GetY,expsize[type],cred[type],cgreen[type],cblue[type],expexpand[type]);
//		CreateExplosion(GetX,GetY,expsize[type],cred[type],cgreen[type],cblue[type],expexpand[type]/2);

		CreateExplosion(0,GetX,GetY,expsize[type],[cred[arg4[1][enemynum]]-prand(0,100),cgreen[arg4[1][enemynum]]-prand(0,100),cblue[arg4[1][enemynum]]-prand(0,100)],expexpand[type]);
		CreateExplosion(0,GetX,GetY,expsize[type],[cred[arg4[1][enemynum]]-prand(0,100),cgreen[arg4[1][enemynum]]-prand(0,100),cblue[arg4[1][enemynum]]-prand(0,100)],expexpand[type]/2);
		CreateExplosion(0,GetX,GetY,expsize[type],[cred[arg4[1][enemynum]]-prand(0,100),cgreen[arg4[1][enemynum]]-prand(0,100),cblue[arg4[1][enemynum]]-prand(0,100)],expexpand[type]/4);

	}
    }

}
