
	let GCSD=GetCurrentScriptDirectory;

	let imgOverload1=GPSD~"img\overload.png";
	let imgOverload2=GPSD~"img\overloadaura.png";
	let imgOverloadBig=GPSD~"img\overload_cutin.png";

	let bgscroll=-200;
	let nameopacity=0;
	let OverloadFrame=0;
	let lightningoffsetmult=0.5;

	let eix=[];
	let eiy=[];
	let eiv=[];
	let eia=[];
	let eit=[];
	let ei=0;

	let armpos=[[-1,-1],[-1,-1]];
	let armposc=[[-1,-1],[-1,-1]];

	let ovaurat=[0,-20,-40,-60];
	let ovaurao=[R4,R4,R4,R4];
	let ovaurar=[Rr,Rr,Rr,Rr];

	function R4{return rand_int(0,3);}
	function Rr{return rand_int(0,360);}


function OverloadDrawLogic{
	let i=0;
	//drawloop
	HandleArms;
	OverloadFrame++;
	loop(4){
		ovaurat[i]=ovaurat[i]+2;
		ovaurar[i]=ovaurar[i]+(i%2-0.5)*4;
		if(ovaurat[i]>=80){
			ovaurao[i]=R4;
			ovaurat[i]=0;
			ovaurar[i]=Rr;
		}
		i++;
	}
	i=0;
	loop(13){
		ovrand[i]=prand(0,1);
		i++;
	}
	ovrandcurrent=OverloadFrame;
	CyberDrawLogic(50,50);
}

sub HandleArms{
	if(armpos==[[-1,-1],[-1,-1]]){
		armpos=[[GetX-50,GetY],[GetX+50,GetY]];
	}
	if(armposc==[[-1,-1],[-1,-1]]){
		armposc=[[GetX-50,GetY],[GetX+50,GetY]];
	}
	let x=0;
	let y=0;
	let xc=0;
	let yc=0;
	let k=0;
	let angle=0;
	let dist=0;
	loop(2){
		x=armpos[k][0];
		y=armpos[k][1];
		xc=armposc[k][0];
		yc=armposc[k][1];
		angle=atan2(y-yc,x-xc);
		dist=distance(x,y,xc,yc)^0.5;
		xc+=cos(angle)*dist/5;
		yc+=sin(angle)*dist/5;

		armposc[k]=[xc,yc];
		k++;
	}
	
	armpos=[[-1,-1],[-1,-1]];
}


function SetColorR(offset){
	SetColor(Rainbow(0,bgscroll/3+offset)*255,Rainbow(1,bgscroll/3+offset)*255,Rainbow(2,bgscroll/3+offset)*255);
}
sub ResetColor{SetColor(255,255,255);}

let ovrect=[[0,0],[128,0],[0,128],[128,128]];
let ovrand=[0,0,0,0,0,0,0,0,0,0,0,0,0];
let ovrandcurrent=0;
let ovcosa=0;
let ovsina=0;

function rand2(num1,num2){
	ovrandcurrent++;
	return num1+(num2-num1)*ovrand[ovrandcurrent%13];
}
function rand_int2(num1,num2){
	ovrandcurrent++;
	return num1+(trunc(ovrand[ovrandcurrent%13]*10000)%((num2-num1)+1));
}
function RandDir2{
	return (rand_int2(0,1)-0.5)*2;
}

function OverloadDrawLoop {
	CyberDraw;
	let i=0;
	let d=0;
	let a=0;
	let yo=sin(OverloadFrame*4)*2;
	SetTexture(imgOverload2);
	SetRenderState(ADD);
	SetAlpha(255);
	loop(4){
		if(ovaurat[i]>=0){
			SetGraphicRect(ovrect[ovaurao[i]][0],ovrect[ovaurao[i]][1],ovrect[ovaurao[i]][0]+128,ovrect[ovaurao[i]][1]+128);
			SetGraphicAngle(0,0,ovaurar[i]);
			SetGraphicScale(ovaurat[i]/40,ovaurat[i]/40);
			SetColor(lower((80-ovaurat[i])*6,250),lower((80-ovaurat[i])*6,250),lower((80-ovaurat[i])*6,250));
			DrawGraphic(GetX,GetY);
		}
		i++;
	}

	ResetColor;
	SetGraphicScale(0.3,0.3);

	loop(2){
		d=rand_int2(0,3);
		SetGraphicRect(ovrect[d][0],ovrect[d][1],ovrect[d][0]+128,ovrect[d][1]+128);
		SetGraphicAngle(0,0,rand2(0,360));
		DrawGraphic(GetX+2,GetY-50+yo);
	}

	SetTexture(imgOverload1);

	SetGraphicRect(196,0,256,64);
	SetColor(96,96,96);
	SetGraphicAngle(0,0,OverloadFrame*2);
	SetGraphicScale(2,2);
	SetAlpha(100);
	DrawGraphic(GetX+2,GetY-50+yo);

	SetGraphicRect(128,0,192,64);
	SetColor(255,255,rand2(50,120));
	SetGraphicAngle(0,0,rand2(0,360));
	SetGraphicScale(1+sin(OverloadFrame*4)*0.1,1+sin(OverloadFrame*4)*0.1);
	SetRenderState(ALPHA);
	SetAlpha(100);
	DrawGraphic(GetX+2,GetY-50+yo);

	SetRenderState(ADD);
	SetColor(rand_int2(200,255),rand_int2(200,255),rand_int2(100,155));
	i=0;
	loop(2){
		d=distance(GetX,GetY,armposc[i][0],armposc[i][1])^0.5;
		a=atan2(GetY-armposc[i][1],GetX-armposc[i][0]);
		SetGraphicRect(0,32,32,64);
		SetGraphicScale(1,d/32+0.5);
		ovcosa=cos(a);
		ovsina=sin(a);
		loop(Detail(3,2,1)){
			SetGraphicAngle(0,0,a+90*RandDir2);
			DrawGraphic(GetX-ovcosa*(d/2)+rand2(-6,6),GetY-ovsina*(d/2)+rand2(-6,6)+yo);
		}
		i++;
	}


	SetRenderState(ALPHA);
	SetGraphicRect(64,0,128,128);
	SetGraphicAngle(0,0,0);
	SetAlpha(255);
	SetGraphicScale(1,1);
	ResetColor;
	DrawGraphic(GetX,GetY-10+yo);

	SetGraphicRect(32,32,64,64);

	a=atan2(GetY-armposc[0][1],GetX-armposc[0][0]);
	ovcosa=cos(a);
	ovsina=sin(a);
	SetGraphicScale(1.2,1.2);
	SetGraphicAngle(0,0,a);
	DrawGraphic(armposc[0][0]+ovcosa*15,armposc[0][1]+ovsina*15+yo);

	//a=atan2(GetY-armposc[1][1],GetX-armposc[1][0]);
	a+=180;
	ovcosa=-ovcosa;
	ovsina=-ovsina;
	SetGraphicScale(-1.2,1.2);
	SetGraphicAngle(0,0,a+180);
	DrawGraphic(armposc[1][0]+ovcosa*15,armposc[1][1]+ovsina*15+yo);


	SetRenderState(ADD);
	SetGraphicRect(129,64,255,128);
	SetGraphicScale(1,0.7);
	loop(Detail(4,3,2)){
		SetColor(200,200,200);
		SetGraphicAngle(0,0,90+rand2(0,20)*RandDir2+rand_int2(0,1)*180);
		DrawGraphic(GetX+rand2(-20,20),GetY+rand2(-10,10));
	}
	SetGraphicScale(0.3,0.3);

	//a=atan2(GetY-armposc[0][1],GetX-armposc[0][0]);
	a-=180;
	ovcosa=-ovcosa;
	loop(Detail(3,2,1)){
		SetColor(150,150,rand2(50,100));
		SetGraphicAngle(0,0,rand2(0,360));
		DrawGraphic(armposc[0][0]+rand2(-10,10)+ovcosa*15,armposc[0][1]+rand2(-10,10)+yo);
	}
	a+=180;
	ovcosa=-ovcosa;
	loop(Detail(3,2,1)){
		SetColor(250,250,rand2(150,200));
		SetGraphicAngle(0,0,rand2(0,360));
		DrawGraphic(armposc[1][0]+rand2(-10,10)+ovcosa*15,armposc[1][1]+rand2(-10,10)+yo);
	}

	SetGraphicScale(1,1);
}

function SetArmPosition(arm,x,y){
	armpos[arm]=[x,y];
}

let shot=[0];
let shotx=[0];
let shoty=[0];
let shotxv=[0];
let shotyv=[0];

function NormalShot(x,y,v,a,g,vulnerability){
	let obj=Obj_Create(OBJ_SHOT);

	shot=shot~[obj];
	shotx=shotx~[x];
	shoty=shoty~[y];
	shotxv=shotxv~[cos(a)*v];
	shotyv=shotyv~[sin(a)*v];

	Obj_SetPosition   (obj, x,y);
	Obj_SetSpeed      (obj, 0);
	ObjShot_SetGraphic(obj, g);
	ObjShot_SetDelay  (obj, 0);
	Obj_SetAutoDelete(obj,false);
	ObjShot_SetBombResist(obj,vulnerability);
	Obj_SetAngle(obj, 0);

}
task HandleShots(threshold){
	let k=0;
	loop{
		k=0;
		loop(length(shotx)-1){
			shotx[k+1]=shotx[k+1]+shotxv[k+1];
			shoty[k+1]=shoty[k+1]+shotyv[k+1];
			Obj_SetPosition(shot[k+1],shotx[k+1],shoty[k+1]);
			if(OffScreen(shotx[k+1],shoty[k+1],threshold)){
				Obj_Delete(shot[k+1]);
				shot=erase(shot,k+1);
				shotx=erase(shotx,k+1);
				shoty=erase(shoty,k+1);
				shotxv=erase(shotxv,k+1);
				shotyv=erase(shotyv,k+1);
				k--;
			}
			k++;
		}
		yield;
		yield;
	}
}

task MagnetShot(x,y,v,a,time,range,strength){
    SE("lightning");

    let angle=0;
    loop(20){
	angle=prand(0,360);
	Spark(x,y,cos(angle)*prand(2,4),sin(angle)*prand(2,4),angle,prand(10,60));
    }

    let obj = Obj_Create(OBJ_EFFECT);
    let frame=0;
    let timer=0;
    let bounces=0;
    let type=0;
    if(strength>0){type=32;}

    // initial settings
    Obj_SetPosition   (obj, x,y);
    Obj_SetSpeed      (obj, 0);
    Obj_SetAngle(obj, 0);
    ObjEffect_SetTexture(obj,imgOverload1);
    ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
    ObjEffect_CreateVertex(obj,4);

    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,type,0);
    ObjEffect_SetVertexUV(obj,1,type+32,0);
    ObjEffect_SetVertexUV(obj,2,type+32,32);
    ObjEffect_SetVertexUV(obj,3,type,32);

    angle=0;
    let k=0;
    let dist=0;

    while(! Obj_BeDeleted(obj)&&time>0) {
	Obj_SetPosition(obj,x,y);
	angle=prand(0,360);
	//Spark(x+cos(angle)*20,y+sin(angle)*20,cos(a)*v+cos(angle+90)*0,sin(a)*v+sin(angle+90)*0,angle+90,10);
	if(time%Detail(2,3,4)==0){
		Spark(x+cos(angle)*15,y+sin(angle)*15,cos(a)*v,sin(a)*v,angle+90,10);
		if(type==0){//positive
			Spark(x+cos(angle)*16,y+sin(angle)*16,cos(a)*v+cos(angle)*1.5,sin(a)*v+sin(angle)*1.5,angle,15);
		}else{//negative
			Spark(x+cos(angle)*36,y+sin(angle)*36,cos(a)*v-cos(angle)*1.5,sin(a)*v-sin(angle)*1.5,angle,15);
		}
	}

	x+=cos(a)*v;
	y+=sin(a)*v;
	if(time%3==0){
		k=0;
		loop(length(shotx)-1){
			angle=atan2(Obj_GetY(obj)-shoty[k+1],Obj_GetX(obj)-shotx[k+1]);
			dist=range-lower((distance(Obj_GetX(obj),Obj_GetY(obj),shotx[k+1],shoty[k+1])^0.5),range);
			shotxv[k+1]=shotxv[k+1]+((cos(angle)*dist)/1600)*strength*3;
			shotyv[k+1]=shotyv[k+1]+((sin(angle)*dist)/1600)*strength*3;
			k++;
		}
	}
	time--;
        yield;
    }
    let k=0;
    let alpha=255;
    loop(30){
	Obj_SetPosition(obj,x,y);
	x+=cos(a)*v;
	y+=sin(a)*v;
	alpha-=255/30;
	k=0;
	loop(4){
		ObjEffect_SetVertexColor(obj,k,alpha,255,255,255);
		k++;
	}
	yield;
    }
    Obj_Delete(obj);
}

task Spark(x,y,xv,yv,a,time){
    let totaltime=time;

    let obj = Obj_Create(OBJ_EFFECT);
    // initial settings
    Obj_SetPosition   (obj, x,y);
    Obj_SetSpeed      (obj, 0);
    Obj_SetAngle(obj, 0);
    ObjEffect_SetTexture(obj,imgOverload1);
    ObjEffect_SetRenderState(obj,ADD);
    ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
    ObjEffect_CreateVertex(obj,4);
    ObjEffect_SetAngle(obj,0,0,a+90);

    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,0,33);
    ObjEffect_SetVertexUV(obj,1,32,33);
    ObjEffect_SetVertexUV(obj,2,32,64);
    ObjEffect_SetVertexUV(obj,3,0,64);

    let angle=0;
    let k=0;
    let alpha=255;
    while(time>0) {
	Obj_SetPosition(obj,x,y);
	x+=xv;
	y+=yv;
	k=0;

	time--;
        yield;
    }
    Obj_Delete(obj);
}
function InitSpark{
    let obj = Obj_Create(OBJ_EFFECT);
    // initial settings
    ObjEffect_SetTexture(obj,imgOverload1);
    ObjEffect_SetRenderState(obj,ADD);
    ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
    ObjEffect_CreateVertex(obj,4);

    ObjEffect_SetVertexXY(obj,0,-16,-32);
    ObjEffect_SetVertexXY(obj,1, 16,-32);
    ObjEffect_SetVertexXY(obj,2, 16,0);
    ObjEffect_SetVertexXY(obj,3,-16,0);
    ObjEffect_SetVertexUV(obj,0,0,33);
    ObjEffect_SetVertexUV(obj,1,32,33);
    ObjEffect_SetVertexUV(obj,2,32,64);
    ObjEffect_SetVertexUV(obj,3,0,64);

    return obj;
}
task LightningLaser(x,y,angle,slope,l,w,seg,g,d,offset){
	let a=[angle+slope,angle-slope];
	let current=0;
	let cosa=[cos(a[0]),cos(a[1]), cos((a[0]+a[1])/2)];
	let sina=[sin(a[0]),sin(a[1]), sin((a[0]+a[1])/2)];
	while(!OffScreen(x,y,0)){
		LightningLaserPart(x,y,a[current%2],l*(lower(current+1,2)/2),w,seg,g,d);
		Wait(d);
		x+=cosa[current%2]*l*(lower(current+1,2)/2);
		x+=cosa[2]*offset;
		y+=sina[current%2]*l*(lower(current+1,2)/2);
		y+=sina[2]*offset;
		current++;
	}
}
let lightninglaseralpha=180;

/*
task LightningLaserPart(x,y,a,l,w,seg,g,d){
	let k=0;

	let obj = Obj_Create(OBJ_LASER);

	// initial settings
	Obj_SetPosition   (obj, x,y);
	Obj_SetSpeed	  (obj, 0);
	ObjShot_SetGraphic(obj, g);
	ObjShot_SetDelay  (obj, 0);
	Obj_SetAngle(obj, a);
	Obj_SetAlpha(obj,lightninglaseralpha);
	ObjShot_SetBombResist(obj,true);
	ObjLaser_SetLength(obj,0);
	ObjLaser_SetSource(obj,false);
	Obj_SetAutoDelete(obj,true);
	ObjShot_ToItem(obj,false);

	DisplayLightning(obj,a,w);
	let lengthen=l/d;
	let length=0;
	let frame=0;
	loop(d){
		length+=lengthen;
		ObjLaser_SetLength(obj,length);
		if(frame%3==0){
			Obj_SetAlpha(obj,lightninglaseralpha*rand(0.5,1));
		}
		frame++;
		yield;
	}
	loop((seg-1)*d){
		if(frame%3==0){
			Obj_SetAlpha(obj,lightninglaseralpha*rand(0.5,1));
		}
		frame++;
		yield;
	}
	Obj_SetCollisionToPlayer(obj,false);
	let cosa=cos(a);
	let sina=sin(a);
	loop(d){
		length-=lengthen;
		ObjLaser_SetLength(obj,length);
		x+=cosa*lengthen;
		y+=sina*lengthen;
		Obj_SetPosition(obj,x,y);
		if(frame%3==0){
			Obj_SetAlpha(obj,lightninglaseralpha*rand(0.5,1));
		}
		frame++;
		yield;
	}
	Obj_Delete(obj);
}
*/

task LightningLaserPart(x,y,a,l,w,seg,g,d){
	let k=0;

	let objd = Obj_Create(OBJ_LASER);	//delay obj

	// initial settings
	Obj_SetPosition   (objd, x,y);
	ObjShot_SetGraphic(objd, g);
	Obj_SetAngle(objd, a);
	ObjShot_SetBombResist(objd,true);
	ObjLaser_SetSource(objd,false);
	ObjShot_ToItem(objd,false);
	Obj_SetCollisionToPlayer(objd,false);
	ObjLaser_SetWidth(objd,3);

//	DisplayLightning(objd,a,3);
	let lengthen=l/d;
	let length=0;
	let frame=0;
	loop(d){
		length+=lengthen;
		ObjLaser_SetLength(objd,length);
		if(frame%3==0){
			Obj_SetAlpha(objd,lightninglaseralpha*rand(0.5,1));
		}
		frame++;
		yield;
	}
	Wait(d/2);

	let obj = Obj_Create(OBJ_LASER);
	Obj_SetPosition   (obj, x,y);
	ObjShot_SetGraphic(obj, g);
	Obj_SetAngle(obj, a);
	ObjShot_SetBombResist(obj,true);
	ObjLaser_SetSource(obj,false);
	ObjShot_ToItem(obj,false);
	ObjLaser_SetWidth(obj,w);

	DisplayLightning(obj,a,w);

	length=0;
	loop(d){
		length+=lengthen;
		ObjLaser_SetLength(obj,length);
		if(frame%3==0){
			Obj_SetAlpha(obj,lightninglaseralpha*rand(0.5,1));
			Obj_SetAlpha(objd,lightninglaseralpha*rand(0.5,1));
		}
		frame++;
		yield;
	}
	ObjShot_FadeDelete(objd);
	loop((seg-1)*d){
		if(frame%3==0){
			Obj_SetAlpha(obj,lightninglaseralpha*rand(0.5,1));
		}
		frame++;
		yield;
	}
	Obj_SetCollisionToPlayer(obj,false);
	let cosa=cos(a);
	let sina=sin(a);
	loop(d){
		length-=lengthen;
		ObjLaser_SetLength(obj,length);
		x+=cosa*lengthen;
		y+=sina*lengthen;
		Obj_SetPosition(obj,x,y);
		if(frame%3==0){
			Obj_SetAlpha(obj,lightninglaseralpha*rand(0.5,1));
		}
		frame++;
		yield;
	}
	Obj_Delete(obj);
}


let lightninggfxx=[1,0,1,0,1];
let lightninggfxy=[1,2,2,3,3];

task DisplayLightning(obj,a,width){
	let followangle=false;
	if(a==NULL){
		followangle=true;
	}
	yield;
	let x1=Obj_GetX(obj);
	let y1=Obj_GetY(obj);

	let objs1=InitEffect(x1,y1,imgOverload1,4,ADD,3);
	ObjEffect_SetAngle(objs1,0,0,a);

	let offset=0;
	let flip;
	let graphic;
	while(!Obj_BeDeleted(obj)){
		ObjEffect_SetScale(objs1,ObjLaser_GetLength(obj)/32,RandDir*rand(0.5,1));
		offset=(rand(0,width)-width/2)*lightningoffsetmult;
		flip=rand_int(0,1);
		ObjEffect_SetXYRect(objs1,32*(1-flip),-width+offset,32*flip,width+offset);
		graphic=rand_int(0,4);
		ObjEffect_SetUVRect(objs1,lightninggfxx[graphic]*128,lightninggfxy[graphic]*64,lightninggfxx[graphic]*128+128,lightninggfxy[graphic]*64+64);

		loop(rand_int(2,4)){
			if(followangle){ObjEffect_SetAngle(objs1,0,0,Obj_GetAngle(obj));}
			yield;
		}
	}
	Obj_Delete(objs1);
}
sub OverInit{
}
sub OverFinalize{
}