  let img_effects = GetCurrentScriptDirectory~"playereffects.png";

  let focusrot1=[120,180,240,300,0,60,120,180,240,300,0,60];let focusrots1=[ 2,-2, 2,-2, 2,-2,-2, 2,-2, 2,-2, 2];
  let focusrot2=[240,300,0,60,120,180,240,300,0,60,120,180];let focusrots2=[ 1, 1,-1,-1, 1, 1, 1, 1,-1,-1, 1, 1];
  let focusrot3=[0,240,120,180,60,300,0,240,120,180,60,300];let focusrots3=[ 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1];

  let effectfocus=0;
  let invincframe=0;
  let dead=0;

  let objfocus=[];
  let singlefocus=0;
  let defaulthitbox=0;
  let singlefocussize=0;
  let hitboxcolor=0;
  let lasthitboxcolor=0;

  let lastgrazecount=0;
  let timesincelastgraze=120;

sub EffectsLogic{
	timesincelastgraze++;
	if(GetEnemyShotCountEx(GetPlayerX,GetPlayerY,60,ALL)>0){
		timesincelastgraze=60;
	}
	if(GetGraze>lastgrazecount){
		lastgrazecount=GetGraze;
		timesincelastgraze=0;
	}
	let boxtype=GetCommonDataDefault("OptionsMenu",[0,0,defaulthitbox])[2];
	if(boxtype==0&&effectfocus>2){
		let k=0;
		loop(12){
			focusrot1[k]=range360(focusrot1[k]+focusrots1[k]);
			focusrot2[k]=range360(focusrot2[k]+focusrots2[k]);
			focusrot3[k]=range360(focusrot3[k]+focusrots3[k]);
			k++;
		}
	}
	if(GetKeyState(VK_SLOWMOVE)==KEY_HOLD){
		if(timesincelastgraze<120){
			effectfocus++;
		}else{
			effectfocus-=0.4;
		}

		if(singlefocussize>1){singlefocussize-=0.25;}
		if(singlefocussize==0){singlefocussize=3;}
	}else{
		effectfocus--;

		if(singlefocussize>0){singlefocussize-=0.05;}
	}
	if(effectfocus<0){effectfocus=0;}
	if(effectfocus>20){effectfocus=20;}
	if(GetKeyState(VK_SLOWMOVE)==KEY_PUSH){
		singlefocussize=3;
	}
	if(GetKeyState(VK_SLOWMOVE)==KEY_PULL){
		singlefocussize=1;
	}
	invincframe++;
	if(invincframe>20){invincframe=0;}
}
function range360(input){
	while(input<0){input+=360;}
	while(input>360){input-=360;}
	return input;
}
let prevfocus=0;
sub DrawFocus{
	let boxtype=GetCommonDataDefault("OptionsMenu",[0,0,defaulthitbox,0,0])[2];
	let k=0;
	let k2=0;
	if(boxtype==0){
		loop(12){
			ObjEffect_SetAngle(objfocus[k],focusrot1[k],focusrot2[k],focusrot3[k]);
			Obj_SetPosition(objfocus[k],round(GetPlayerX),round(GetPlayerY));

			if(prevfocus!=effectfocus){
				k2=0;
				loop(4){
					ObjEffect_SetVertexColor(objfocus[k],k2,(effectfocus/20)*255,255*(k%2),255*(k%2),255*(k%2));
					k2++;
				}
	
			}
			k++;
		}
		prevfocus=effectfocus;
	}else if(boxtype==1){
		if(hitboxcolor!=lasthitboxcolor){
			ObjEffect_SetVertexUV(singlefocus,0,65+hitboxcolor*10,65);
			ObjEffect_SetVertexUV(singlefocus,1,72+hitboxcolor*10,65);
			ObjEffect_SetVertexUV(singlefocus,2,72+hitboxcolor*10,72);
			ObjEffect_SetVertexUV(singlefocus,3,65+hitboxcolor*10,72);
			lasthitboxcolor=hitboxcolor;
		}
		Obj_SetPosition(singlefocus,round(GetPlayerX),round(GetPlayerY));
		ObjEffect_SetScale(singlefocus,singlefocussize,singlefocussize);
//		k2=0;
//		loop(4){
//			ObjEffect_SetVertexColor(singlefocus,k2,255,255,255,255);
//			k2++;
//		}
	}
}
function InvincibilityAlpha{
	let ret=255;
	if(GetTimeOfPlayerInvincibility>0){
		ret=sin(invincframe*30)*80+174;
	}
	return ret;
}
task EffectTask{
	let k=0;
	let k2=0;
	loop(12){
		objfocus=objfocus~[Obj_Create(OBJ_EFFECT)];
		ObjEffect_SetTexture(objfocus[k],img_effects);
		ObjEffect_SetScale(objfocus[k],0.5,1);
		ObjEffect_SetLayer(objfocus[k],4);
		Obj_SetSpeed(objfocus[k],500);
		Obj_SetAutoDelete(objfocus[k],false);
		ObjEffect_SetRenderState(objfocus[k],ALPHA);
		ObjEffect_CreateVertex(objfocus[k],4);
		ObjEffect_SetPrimitiveType(objfocus[k],PRIMITIVE_TRIANGLEFAN);
		ObjEffect_SetVertexUV(objfocus[k],0,0,0);
		ObjEffect_SetVertexUV(objfocus[k],1,65,0);
		ObjEffect_SetVertexUV(objfocus[k],2,65,65);
		ObjEffect_SetVertexUV(objfocus[k],3,0,65);
		ObjEffect_SetVertexXY(objfocus[k],0,-32,-32);
		ObjEffect_SetVertexXY(objfocus[k],1, 32,-32);
		ObjEffect_SetVertexXY(objfocus[k],2, 32, 32);
		ObjEffect_SetVertexXY(objfocus[k],3,-32, 32);
		k2=0;
		loop(4){
			ObjEffect_SetVertexColor(objfocus[k],k2,0,255*(k%2),255*(k%2),255*(k%2));
			k2++;
		}
		k++;
	}
	singlefocus=Obj_Create(OBJ_EFFECT);
	ObjEffect_SetTexture(singlefocus,img_effects);
	Obj_SetPosition(singlefocus,0,0);
	ObjEffect_SetScale(singlefocus,1,1);
	Obj_SetAngle(singlefocus,-90);
	ObjEffect_SetLayer(singlefocus,4);
	Obj_SetSpeed(singlefocus,500);
	Obj_SetAutoDelete(singlefocus,false);
	ObjEffect_SetRenderState(singlefocus,ALPHA);
	ObjEffect_CreateVertex(singlefocus,4);
	ObjEffect_SetPrimitiveType(singlefocus,PRIMITIVE_TRIANGLEFAN);
	ObjEffect_SetVertexUV(singlefocus,0,65,65);
	ObjEffect_SetVertexUV(singlefocus,1,72,65);
	ObjEffect_SetVertexUV(singlefocus,2,72,72);
	ObjEffect_SetVertexUV(singlefocus,3,65,72);
	ObjEffect_SetVertexXY(singlefocus,0,-3,-3);
	ObjEffect_SetVertexXY(singlefocus,1, 4,-3);
	ObjEffect_SetVertexXY(singlefocus,2, 4, 4);
	ObjEffect_SetVertexXY(singlefocus,3,-3, 4);
	k=0;
	loop(4){
		ObjEffect_SetVertexColor(singlefocus,k,255,255,255,255);
		k++;
	}

}
sub HandleDeath{
	if(dead==0){
		dead=1;
		let k=1;
		loop(3){
			RainbowExplosion(GetPlayerX,GetPlayerY,k*10,k+2,1);
			k++;
		}
		RainbowExplosion(GetPlayerX,GetPlayerY,30,5,0);
		RainbowExplosion(GetPlayerX,GetPlayerY,60,50,0);
	}
}

task HandleDeath2{
	if(dead==0){
		dead=1;
		let color1=0;
		let color2=60;
		if(ExPlayer){
			color1=150;
			color2=250;
		}
		let i=0;
		let rot1;
		let rot2;
		loop(8){
			rot1=[rand(-70,70),rand(-70,70),rand(0,360)];
			rot2=rand(1.5,2.5)*RandDir;
			LightRays(GetPlayerX,GetPlayerY,rot1,rot2,3,i*5+5,10,i,RainbowArray(color1,170,85),1, 0);
			LightRays(GetPlayerX,GetPlayerY,rot1,rot2,3,i*5+5,10,i,RainbowArray(color2,170,85),-1, 0);
			i++;
		}
		Death2B(5);
		Death2B(4);
		Death2B(3);

		let expand=5;
		let frame=0;
		loop(50){
			Explosion(GetPlayerX,GetPlayerY,0.1,[rand(0,220),rand(0,220),rand(0,220)],rand(expand/3,expand),frame%2,16);
			expand-=5/50;
			frame++;
			yield;
		}
	}
}
task Death2B(size){
	let obj=InitEffect(GetPlayerX,GetPlayerY,img_effects,4,ADD,2);
	ObjEffect_SetXYRect(obj,-32,-32,32,32);
	ObjEffect_SetUVRect(obj,1,193,63,255);
	let alpha=1;
	let scale=0;
	let k=0;
	loop(40){
		k=0;
		loop(4){
			ObjEffect_SetVertexColor(obj,k,alpha*255,255,255,255);
			k++;
		}
		alpha-=1/40;
		scale+=size/40;
		ObjEffect_SetScale(obj,scale,scale);
		yield;
	}
	Obj_Delete(obj);
}

task LightRays(x,y,angle,rotspeed,maxscale,time,fadetime,delay,color,direction, type){
    let k;
    loop(delay){yield;}
    if(direction==-1){
	angle[2]=angle[2]+180;
    }
    let obj = Obj_Create(OBJ_EFFECT);


    ObjEffect_SetTexture(obj,img_effects);
    ObjEffect_CreateVertex(obj,4);
    ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
    ObjEffect_SetRenderState(obj,ADD); 
    ObjEffect_SetLayer(obj,2);
    ObjEffect_SetXYRect(obj,-100,-64,0,63);
    ObjEffect_SetUVRect(obj,0,128,100,191);
    let scale=0;
    let rotation=0;
    let frame=0;
    let alpha=255;
    loop(time+fadetime){
	Obj_SetPosition(obj,x+ScreenShakeX,y+ScreenShakeY);
//	angle=angle+rotspeed;
	angle=angle+[0,0,rotspeed];

	ObjEffect_SetAngle(obj,angle[0],angle[1],angle[2]);
	if(frame>time){alpha-=255/fadetime;}

	if(type==0){
		if(scale<1){
			scale+=1/10;
		}


		ObjEffect_SetScale(obj,scale*maxscale,maxscale*0.7);
		k=0;
		loop(4){
			ObjEffect_SetVertexColor(obj,k,alpha,color[0],color[1],color[2]);
			k++;
		}
	}else{
		if(scale<1){
			scale+=1/time;
		}

		ObjEffect_SetScale(obj,maxscale,maxscale*0.7);
		k=0;
		loop(4){
			ObjEffect_SetVertexColor(obj,k,alpha,color[0]*scale,color[1]*scale,color[2]*scale);
			k++;
		}
	}

	frame++;
	yield;
    }
    Obj_Delete(obj);
}


task Explosion(ex,ey,es,color,e,static,frames){
    let obj = Obj_Create(OBJ_EFFECT);
    let alpha=240;

    Obj_SetPosition   (obj, ex,ey);
    Obj_SetSpeed      (obj, 0);
    Obj_SetAngle      (obj, 0);
    ObjEffect_SetTexture(obj,img_effects);
    ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
    ObjEffect_SetScale(obj,1,1);
    if(static==0){
	ObjEffect_SetAngle(obj,rand(-80,80),rand(-80,80),rand(0,360));
    }else{
	ObjEffect_SetAngle(obj,0,0,rand(0,360));
    }

    ObjEffect_SetLayer(obj,2);
    ObjEffect_CreateVertex(obj,4);
    ObjEffect_SetRenderState(obj,ADD);

    ObjEffect_SetXYRect(obj,-32,-32,32,32);
    ObjEffect_SetUVRect(obj,1+64,193,63+64,255);

    let n=0;
    loop(frames){
	Obj_SetPosition(obj,ex,ey);
	n=0;
	loop(4){
		ObjEffect_SetVertexColor(obj,n,alpha,color[0],color[1],color[2]);
		n++;
	}
	ObjEffect_SetScale(obj,es/2,es/2);
	alpha-=(240/frames);
	es=es+e*2;
	yield;
    }
    Obj_Delete(obj);
}



task RainbowExplosion(x,y,time,maxsize,angletype){
		let size=0;
		let sizeadd=maxsize/time;
		let alpha=255;
		let alphaadd=255/time;
		let k=0;
		let angle=[rand(0,360),rand(0,360),rand(0,360)];
		let angleadd=[rand(-2,2),rand(-2,2),rand(6,10)*(rand(0,1)-0.5)];

		let obj=Obj_Create(OBJ_EFFECT);
		ObjEffect_SetTexture(obj,img_effects);
		ObjEffect_SetLayer(obj,3);
		Obj_SetAutoDelete(obj,false);
		ObjEffect_SetRenderState(obj,ADD);
		ObjEffect_CreateVertex(obj,4);
		ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
		ObjEffect_SetVertexUV(obj,0,65,1);
		ObjEffect_SetVertexUV(obj,1,128,1);
		ObjEffect_SetVertexUV(obj,2,128,64);
		ObjEffect_SetVertexUV(obj,3,65,64);
		ObjEffect_SetVertexXY(obj,0,-32,-32);
		ObjEffect_SetVertexXY(obj,1, 32,-32);
		ObjEffect_SetVertexXY(obj,2, 32, 32);
		ObjEffect_SetVertexXY(obj,3,-32, 32);
		Obj_SetPosition(obj,x,y);
		loop(time){
			size+=sizeadd;
			alpha-=alphaadd;
			k=0;
			loop(3){
				angle[k]=angle[k]+angleadd[k];
				k++;
			}
			ObjEffect_SetScale(obj,size,size);
			if(angletype==0){
				ObjEffect_SetAngle(obj,0,0,angle[2]);
			}else{
				ObjEffect_SetAngle(obj,angle[0],angle[1],angle[2]);
			}
			k=0;
			loop(4){
				ObjEffect_SetVertexColor(obj,k,alpha,255,255,255);
				k++;
			}
			yield;
		}
		Obj_Delete(obj);
}
let StopEffect=0;
task SpellCardEffect{
//	PlaySE(GetCurrentScriptDirectory~"sePlayerSpellCard.wav");
	let k=1;
	StopEffect=0;
	loop(15){
		SpellcardExplosion(40+k*5,2*(16-k),k%2,1);
		k++;
	}
	while(StopEffect==0){
		SpellcardExplosion(30,5,k%2,1);
		k++;
		yield;
		yield;
		yield;
		yield;
		yield;
	}
}
task SpellCardEffectSmall{
//	PlaySE(GetCurrentScriptDirectory~"sePlayerSpellCard.wav");
	let k=1;
	loop(5){
		SpellcardExplosion(40+k*5,2*(5-k),k%2,1);
		k++;
	}
}
task SpellCardEffectStatic{
//	PlaySE(GetCurrentScriptDirectory~"sePlayerSpellCard.wav");
	let k=1;
	StopEffect=0;
	loop(15){
		SpellcardExplosion(40+k*5,2*(16-k),k%2,0);
		k++;
	}
}
function SpellcardExplosion(time,maxsize,angletype,homing){
	SpellcardExplosion2(GetPlayerX,GetPlayerY,time,maxsize,angletype,homing);
}
function SpellcardExplosionXY(x,y,time,maxsize,angletype,homing){
	SpellcardExplosion2(x,y,time,maxsize,angletype,homing);
}
task SpellcardExplosion2(x,y,time,maxsize,angletype,homing){
		let size=0;
		let sizeadd=maxsize/time;
		let alpha=255;
		let alphaadd=255/time;
		let k=0;
		let angle=[rand(0,360),rand(0,360),rand(0,360)];
		let angleadd=[rand(-2,2),rand(-2,2),rand(6,10)*(rand(0,1)-0.5)];
		let color=[rand(50,255),rand(50,255),rand(50,255)];

		let obj=Obj_Create(OBJ_EFFECT);
		ObjEffect_SetTexture(obj,img_effects);
		ObjEffect_SetLayer(obj,3);
		Obj_SetAutoDelete(obj,false);
		ObjEffect_SetRenderState(obj,ADD);
		ObjEffect_CreateVertex(obj,4);
		ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
		ObjEffect_SetVertexUV(obj,0,1, 65);
		ObjEffect_SetVertexUV(obj,1,63,65);
		ObjEffect_SetVertexUV(obj,2,63,127);
		ObjEffect_SetVertexUV(obj,3,1, 127);
		ObjEffect_SetVertexXY(obj,0,-32,-32);
		ObjEffect_SetVertexXY(obj,1, 32,-32);
		ObjEffect_SetVertexXY(obj,2, 32, 32);
		ObjEffect_SetVertexXY(obj,3,-32, 32);
		Obj_SetPosition(obj,x,y);
		loop(time){
			if(homing!=0){
				Obj_SetPosition(obj,GetPlayerX,GetPlayerY);
			}
			size+=sizeadd;
			alpha-=alphaadd;
			k=0;
			loop(3){
				angle[k]=angle[k]+angleadd[k];
				k++;
			}
			ObjEffect_SetScale(obj,size,size);
			if(angletype==0){
				ObjEffect_SetAngle(obj,0,0,angle[2]);
			}else{
				ObjEffect_SetAngle(obj,angle[0],angle[1],angle[2]);
			}
			k=0;
			loop(4){
				ObjEffect_SetVertexColor(obj,k,alpha,color[0],color[1],color[2]);
				k++;
			}
			if(time%2==0){
				color=[rand(50,255),rand(50,255),rand(50,255)];
			}
			time--;
			yield;
		}
		Obj_Delete(obj);
}




function CreateBG(image,scalex,scaley,angle,rendertype){
	let k2=0;
	let obj=Obj_Create(OBJ_EFFECT);
	Obj_SetPosition(obj,224,240);
	ObjEffect_SetTexture(obj,image);
	ObjEffect_SetScale(obj,scalex,scaley);
	Obj_SetAngle(obj,-90);
	ObjEffect_SetLayer(obj,1);
	Obj_SetSpeed(obj,0);
	Obj_SetAutoDelete(obj,false);
	ObjEffect_SetAngle(obj,angle[0],angle[1],angle[2]);
	ObjEffect_SetRenderState(obj,rendertype);
	ObjEffect_CreateVertex(obj,4);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
	ObjEffect_SetVertexXY(obj,0,-192,-224);
	ObjEffect_SetVertexXY(obj,1, 192,-224);
	ObjEffect_SetVertexXY(obj,2, 192, 224);
	ObjEffect_SetVertexXY(obj,3,-192, 224);
	return obj;
}
function MoveBG(obj,x,y,alpha,clipx,clipy){
	ObjEffect_SetVertexUV(obj,0,0  +x+clipx,0  +y+clipy);
	ObjEffect_SetVertexUV(obj,1,384+x-clipx,0  +y+clipy);
	ObjEffect_SetVertexUV(obj,2,384+x-clipx,448+y-clipy);
	ObjEffect_SetVertexUV(obj,3,0  +x+clipx,448+y-clipy);
	let k2=0;
	loop(4){
		ObjEffect_SetVertexColor(obj,k2,alpha,255,255,255);
		k2++;
	}
}