
	let GCSD=GetCurrentScriptDirectory;

	let imgYukari1=GPSD~"img\yukari1.png";
	let imgYukari2=GPSD~"img\yukarithing.png";
	let imgYukari3=GPSD~"img\yukariclouds.png";
	let imgYukariBig=GPSD~"img\yukari_cutin.png";
	let invincible=false;

	let imgYumemi=GPSD~"img\yumemi.png";
	let imgYumemiCross=GPSD~"img\cross.png";
	let imgYumemiBig=GPSD~"img\yukari_cutin.png";

	let imgGap=GPSD~"img\gap.png";
	let imgGap2=GPSD~"img\gap2.png";

	let nameopacity=0;
	let bginit=0;
	let yukariscroll=0;
	let yalpha=0;

	let cosys=0;
	let sinys=0;


	let gapi=[[0,0]];
	let gapxw=[0];
	let gapyw=[0];
	let gapt=[0];

	let cosgap=[];
	let singap=[];

	let yex=[0,0,0,0,0,0,0,0,0,0];
	let yey=[0,0,0,0,0,0,0,0,0,0];
	let yeyv=[0,0,0,0,0,0,0,0,0,0];
	let yet=[0,0,0,0,0,0,0,0,0,0];
	let yea=[0,0,0,0,0,0,0,0,0,0];
	let yefreq=8;
	let yenum=10;
	let yukarik=0;

sub YukariDrawLogic{
	//drawloop


	ClearRenderTarget("yukarigap");
	SetRenderTarget("yukarigap");
	SetTexture(imgYukari1);
	SetGraphicRect(242,185,244,246);
	SetGraphicScale(256,4.2);
	SetGraphicAngle(0,0,0);
	SetColor(255,255,255);
	SetAlpha(210);
	DrawGraphic(128,128);

	SetTexture(imgYukari3);
	SetGraphicScale(0.25,0.25);
	SetAlpha(255);
	SetGraphicAngle(0,0,-yukariscroll*0.6);
	SetGraphicRect(0+GetX*4+yukariscroll*2,0+GetY*2,1024+GetX*4+yukariscroll*2,1024+GetY*2);
	DrawGraphic(128,128);	
	SetAlpha(150);
	SetGraphicRect(0+GetX*4+yukariscroll*5,512+GetY*2,1024+GetX*4+yukariscroll*5,1024+GetY*2+512);
	DrawGraphic(128,128);	

	SetTexture(imgYukari2);
	SetGraphicScale(1,1);
	SetGraphicAngle(0,0,0);
	SetGraphicRect(0,0,260,260);
	SetRenderState(SUBTRACT);
	DrawGraphic(128,128);
	SetRenderState(ALPHA);
	SetRenderTarget("DEFAULT");

	if(yukariscroll%yefreq==0){
		yex[yukariscroll/yefreq%yenum]=rand(-30,30)+GetX;
		yey[yukariscroll/yefreq%yenum]=rand(-30,70)+GetY;
		yeyv[yukariscroll/yefreq%yenum]=rand(-2,0);
		yet[yukariscroll/yefreq%yenum]=yukariscroll;
	}
	yea[rand_int(0,yenum-1)]=rand(0,1);

	yukariscroll++;
}
let gapvertices=13;
function SetGapVertices(num){
	gapvertices=num;
}

sub YukariDrawLoop {
	SetTexture("yukarigap");
	SetGraphicRect(1,1,256,256);
	SetGraphicScale(1,1);
	SetGraphicAngle(0,0,yukariscroll*0.6);
	SetAlpha(255);
	SetColor(255,255,255);
	DrawGraphic(GetX+ScreenShakeX,GetY+ScreenShakeY);

	cosys=cos(yukariscroll);
	sinys=sin(yukariscroll);

	SetTexture(imgYukari1);
	SetGraphicAngle(0,0,0);
	SetRenderState(ADD);

	SetGraphicRect(1+trunc(yukariscroll/4%3)*80,1,79+trunc(yukariscroll/4%3)*80,138);

	SetColor(255,168,168);
	DrawGraphic(trunc(GetX+17+ScreenShakeX+cosys*2),trunc(GetY+cosys*3+ScreenShakeY+sinys*2+3));
	SetColor(255/3,128/3,128/3);
	SetGraphicScale(1.5,1.5);
	DrawGraphic(trunc(GetX+17+ScreenShakeX+cosys*4),trunc(GetY+cosys*3+ScreenShakeY+sinys*4+3));


	SetGraphicRect(1+trunc((yukariscroll+1.5)/4%3)*80,1,79+trunc((yukariscroll+1.5)/4%3)*80,138);

	SetColor(168,168,255);
	SetGraphicScale(1,1);
	DrawGraphic(trunc(GetX+17+ScreenShakeX-cosys*2),trunc(GetY+cosys*3+ScreenShakeY-sinys*2+3));
	SetColor(128/3,128/3,255/3);
	SetGraphicScale(1.5,1.5);
	DrawGraphic(trunc(GetX+17+ScreenShakeX-cosys*4),trunc(GetY+cosys*3+ScreenShakeY-sinys*4+3));

	SetAlpha(255);
	SetRenderState(ALPHA);
	SetColor(255,255,255);
	SetGraphicAngle(0,0,0);
	SetGraphicScale(1,1);
	SetGraphicRect(0+trunc(yukariscroll/6%4)*80,252,80+trunc(yukariscroll/6%4)*80,390);
	DrawGraphic(GetX+11+ScreenShakeX,trunc(GetY)+cosys*3+ScreenShakeY-5);

	SetAlpha(255);
	SetRenderState(ADD);
	SetGraphicRect(81,186,64+80,249);
	SetGraphicScale(0.4,0.4);

	yukarik=0;
	loop(yenum){
		yalpha=sin((yukariscroll-yet[yukarik])*(180/(yefreq*yenum)))*220*yea[yukarik];
		SetColor(yalpha*(yukarik/yenum),yalpha,yalpha*(1-yukarik/yenum));
		DrawGraphic(yex[yukarik],yey[yukarik]+yeyv[yukarik]*(yukariscroll-yet[yukarik]));
		yukarik++;
	}


	DrawFunctions;
}

function YukariDrawLoopTrans(opacity) {
	SetTexture("yukarigap");
	SetGraphicRect(1,1,256,256);
	SetGraphicScale(1,1);
	SetGraphicAngle(0,0,yukariscroll*1.2);
	SetAlpha(255*opacity);
	DrawGraphic(GetX+ScreenShakeX,GetY+ScreenShakeY);

	SetTexture(imgYukari1);
	SetGraphicAngle(0,0,0);
	SetGraphicRect(0,252,80,390);
	SetAlpha(255*opacity);
	DrawGraphic(GetX+8,trunc(GetY)+cos(yukariscroll*3)*3);

	DrawFunctions;
}


task LaserFire(x,y,forwardv,sidev,angle,len,width, starttime,time,fadetime, graphic){
	let xv=cos(angle)*forwardv+cos(angle+90)*sidev;
	let yv=sin(angle)*forwardv+sin(angle+90)*sidev;

	let obj=Obj_Create(OBJ_LASER);
	ObjShot_SetGraphic(obj,graphic);
	ObjLaser_SetSource(obj,false);
	ObjLaser_SetWidth(obj,width);
	ObjLaser_SetLength(obj,len);
	Obj_SetAngle(obj,angle);
	ObjShot_ToItem(obj,false);
	Obj_SetCollisionToPlayer(obj,false);

	let alpha=0;
	loop(starttime){
		CheckFrame;
		alpha+=255/starttime;
		Obj_SetAlpha(obj,alpha);
		yield;
	}
	alpha=255;
	Obj_SetAlpha(obj,alpha);
	loop(time){
		CheckFrame;
		yield;
	}
	loop(fadetime){
		CheckFrame;
		alpha-=255/fadetime;
		Obj_SetAlpha(obj,alpha);
		yield;
	}

	Obj_Delete(obj);

	sub CheckFrame{
		Obj_SetPosition(obj,x,y);
		x+=xv;
		y+=yv;

	}
}
task LaserTrail(obj,angle,type){
	let sina=sin(angle);
	let cosa=cos(angle);
	//type: false=start at base, true=start in center
	let x;
	let y;
	let v;
	let dist;
	let phase=0;
	let alpha=0;
	while(!Obj_BeDeleted(obj)){
		alpha+=1/(30/3);
		dist=ObjLaser_GetLength(obj);
		if(!type){
			dist=dist*rand((phase+1)/8,(phase+2)/8);
			phase++;
			phase%=7;
		}else{
			Wait(4);
			dist=dist*rand(0.3,0.7);
		}
		x=cosa*dist;
		y=sina*dist;
		LaserTrail2(obj,x,y);
		Wait(3);
	}
	task LaserTrail2(obj,x,y){
		let g=[RED50,BLUE50,PURPLE50][rand_int(0,2)];
		let obj2=Obj_Create(OBJ_LASER);
		ObjShot_SetGraphic(obj2,g);
		ObjLaser_SetSource(obj2,false);
		Obj_SetCollisionToPlayer(obj2,false);
		ObjShot_ToItem(obj2,false);
		Obj_SetAngle(obj2,angle);
		Obj_SetAlpha(obj2,alpha*rand(200,255));
		let time=rand_int(30,90);
		let offset=rand(30,60);
		if(type){
			offset*=RandDir;
		}
		let size=0;
		let percent=0;
		let offsetpercent;
		loop(time){
			percent+=1/time;
			offsetpercent=percent*2-1;
			size=(0.5-absolute(0.5-percent))*200;
			ObjLaser_SetWidth(obj2,size*0.3);
			ObjLaser_SetLength(obj2,size);
			Obj_SetPosition(obj2,	Obj_GetX(obj)+x+offset*offsetpercent*cosa-size*0.5*cosa,
						Obj_GetY(obj)+y+offset*offsetpercent*sina-size*0.5*sina);
			yield;
		}
		Obj_Delete(obj2);
	}
}

task BulletPath(x1,y1,x2,y2,inittime,time1,time2,time3){
				   //delay,accel,final
	let graphics=[PURPLE60,GREEN60,WHITE60];

	let width=40;
	let width2;

	let alpha=0;
	let frame=0;

	let angle=atan2(y2-y1,x2-x1);

	let xv=cos(angle);
	let yv=sin(angle);
	let xv2=cos(angle+90);
	let yv2=sin(angle+90);
	x1-=xv*20;
	y1-=yv*20;
	x2+=xv*20;
	y2+=yv*20;

	let dist=distance(x1,y1,x2,y2)^0.5;
	let angle2;

	let obj1=Obj_Create(OBJ_LASER);
	InitLaser(obj1,dist);
	Obj_SetAngle(obj1,angle);
	LaserTrail(obj1,angle,false);

	let obj2=Obj_Create(OBJ_LASER);
	InitLaser(obj2,dist);
	Obj_SetAngle(obj2,angle);
	LaserTrail(obj2,angle,false);

	let obj3=Obj_Create(OBJ_LASER);
	InitLaser(obj3,width);
	Obj_SetAngle(obj3,angle-90);
	LaserTrail(obj3,angle-90,true);

	

	let frame=0;
	loop(inittime+time1){
		frame++;
		if(frame<=inittime){
			width2=sin(frame*(90/inittime)+180)+1;
			alpha+=5/inittime;
		}
		Obj_SetPosition(obj1,x1+xv2*(width+width2*60),y1+yv2*(width+width2*60));
		Obj_SetPosition(obj2,x1-xv2*(width+width2*60),y1-yv2*(width+width2*60));
		Obj_SetPosition(obj3,Obj_GetX(obj1),Obj_GetY(obj1));
		ObjLaser_SetLength(obj3,(width+width2*60)*2+40);

		if(frame%7==0){

			LaserFire(Obj_GetX(obj1)+xv*20,Obj_GetY(obj1)+yv*20,rand(-2,2),rand(-0.5,0.5),angle,dist,alpha, 2,7,10, graphics[rand_int(0,2)]);
			LaserFire(Obj_GetX(obj2)+xv*20,Obj_GetY(obj2)+yv*20,rand(-2,2),rand(-0.5,0.5),angle,dist,alpha, 2,7,10, graphics[rand_int(0,2)]);

			LaserFire(Obj_GetX(obj1)+xv*20,Obj_GetY(obj1)+yv*20,rand(-2,2),rand(-0.5,0.5),angle-90,(width+width2*60)*2,alpha, 2,7,10, graphics[rand_int(0,2)]);
		}

		yield;
	}
	Obj_SetCollisionToPlayer(obj1,true);
	Obj_SetCollisionToPlayer(obj2,true);
	Obj_SetCollisionToPlayer(obj3,true);
	let v=0;
	loop(time2){
		v+=((dist-40)/time3)/time2;
		UpdatePosition;
		yield;
	}
	while(OnScreen(Obj_GetX(obj1),Obj_GetY(obj1),20)){
		UpdatePosition;
		yield;
	}
	Obj_Delete(obj1);
	Obj_Delete(obj2);
	Obj_Delete(obj3);

sub UpdatePosition{
	Obj_SetPosition(obj1,Obj_GetX(obj1)+xv*v,Obj_GetY(obj1)+yv*v);
	Obj_SetPosition(obj2,Obj_GetX(obj2)+xv*v,Obj_GetY(obj2)+yv*v);


	Obj_SetPosition(obj3,Obj_GetX(obj1)+xv2*20+xv*20,Obj_GetY(obj1)+yv2*20+yv*20);

	if(frame%3==0){
		LaserFire(Obj_GetX(obj1)+xv*20,Obj_GetY(obj1)+yv*20,rand(-2,2),rand(-0.5,0.5),angle,dist,5, 2,5,10, RED60+rand_int(0,3));
		LaserFire(Obj_GetX(obj2)+xv*20,Obj_GetY(obj2)+yv*20,rand(-2,2),rand(-0.5,0.5),angle,dist,5, 2,5,10, RED60+rand_int(0,3));

		LaserFire(Obj_GetX(obj1)+xv*20,Obj_GetY(obj1)+yv*20,rand(-2,2),rand(-0.5,0.5)+v,angle-90,width*2,5, 2,5,10, RED60+rand_int(0,3));
	}
	frame++;
}

task InitLaser(obj,len){
	Obj_SetAutoDelete(obj,false);
	Obj_SetCollisionToPlayer(obj,false);
	ObjLaser_SetSource(obj,false);
	ObjLaser_SetLength(obj,len);
	ObjLaser_SetWidth(obj,20);
	ObjShot_SetGraphic(obj,RED01);
	Obj_SetAlpha(obj,0);
	let lastinvinc=true;
	while(!Obj_BeDeleted(obj)){
		if(lastinvinc!=invincible){
			Obj_SetCollisionToPlayer(obj,!invincible);
			lastinvinc=invincible;
		}
		yield;
	}
}

}




let chechox=[0,0,0,0,0,0,0,0,0,0,0,0];
let chechoy=[0,0,0,0,0,0,0,0,0,0,0,0];
let chechot=[0,0,0,0,0,0,0,0,0,0,0,0];
let chechoa=[0,0,0,0,0,0,0,0,0,0,0,0];//angle
let chechoav=[0,0,0,0,0,0,0,0,0,0,0,0];//angle vel
let chechop=[0,0,0,0,0,0,0,0,0,0,0,0];//pose
let chechod=[0,0,0,0,0,0,0,0,0,0,0,0];//dir
let chenangle=0;
let chenpose=0;
let chendir=1;
let lastchenx=GetX;
let lastcheny=GetY;

sub ChenDrawLogic{

	chenpose=0;
	chendir=1;
	if(distance(GetX,GetY,lastchenx,lastcheny)>2){	//if moving
		chenpose=1;
		if(lastchenx<GetX){chendir=-1;}
		chenangle-=chendir*rand(20,25);
	}else{
		chenangle=0;
	}
	lastchenx=GetX;
	lastcheny=GetY;

	yui=0;
	loop(12){
		if(chechot[yui]>0){
			chechot[yui]=chechot[yui]-1;
		}
		chechoa[yui]=chechoa[yui]+chechoav[yui];
		yui++;
	}
	if(yukariscroll%2==0){
		chechox[yukariscroll/2%12]=GetX;
		chechoy[yukariscroll/2%12]=GetY+sin(yukariscroll*3.5)*3;
		chechot[yukariscroll/2%12]=2*12;
		chechoa[yukariscroll/2%12]=chenangle;
		chechoav[yukariscroll/2%12]=rand(-2,2);
		chechop[yukariscroll/2%12]=chenpose;
		chechod[yukariscroll/2%12]=chendir;
	}
	yukariscroll++;
}
sub ChenDrawLoop{
	SetTexture(imgYukari1);

	yui=0;
	loop(12){
		SetGraphicRect(256+64*chechop[yui],100,256+64+64*chechop[yui],200);
		SetGraphicAngle(0,0,chechoa[yui]);
		SetGraphicScale(((24-chechot[yui])/24+1)*chechod[yui],(24-chechot[yui])/24+1);
		SetAlpha(chechot[yui]*10);
		DrawGraphic(chechox[yui]+ScreenShakeX,chechoy[yui]+ScreenShakeY);
		yui++;
	}

	SetGraphicRect(256+64*chenpose,0,256+64+64*chenpose,100);
	SetGraphicAngle(0,0,chenangle);
	SetGraphicScale(chendir,1);
	SetAlpha(255);
	DrawGraphic(round(GetX)+ScreenShakeX,round(GetY+sin(yukariscroll*3.5)*3)+ScreenShakeY);
}

task ChenMoveTask(time,moves,movetime){
//time = total time of animation, moves = number of steps, movetime = time spent actually moving per step in percent (0 to 1)
	let timeper=time/moves;
	let movebackx=GetX;
	let movebacky=GetY;
	loop(moves-1){
		MoveRandom(150,50,GetClipMinX,50,GetClipMaxX,250,150,movetime*timeper);
		loop(timeper){yield;}
	}
	SetMovePositionNew(movebackx,movebacky,movetime*timeper);
}


let gapopacity=1;

let yuframe=0;
let yupose=0;
let yuanim=0;
let yuechox=[0,0,0,0,0,0];
let yuechoy=[0,0,0,0,0,0];
let yuechoxv=[0,0,0,0,0,0];
let yuechoyv=[0,0,0,0,0,0];
let yuechop=[0,0,0,0,0,0];
let yuechot=[0,0,0,0,0,0];

//let yuorbitangle1=[0,180,90,270,0,180,90,270];
//let yuorbitangle2=[0,180,90,270,0,180,90,270];
let yuorbitangle1=[0,90,180,270,0,90,180,270];
let yuorbitangle2=[0,90,180,270,0,90,180,270];
let yuorbitrotspeed1=[0.25,0.25,0.5,0.5,1,1,1.5,1.5];
let yuorbitrotspeed2=[1,1,1.5,1.5,0.25,0.25,0.5,0.5];

let yudistx=[0,0,0,0,0,0,0,0];
let yudisty=[0,0,0,0,0,0,0,0];

function YumemiDrawLogic{
	yupose=trunc(yuframe/6)%4;
	if(yuframe%5==0){
		let var=(yuframe/5)%6;
		yuechox[var]=trunc(GetX);
		yuechoy[var]=trunc(GetY+cos(yuframe*4)*2)-7;
		yuechoxv[var]=rand(-20,20);
		yuechoyv[var]=rand(-20,20);
		yuechop[var]=yuanim;
		yuechot[var]=yuframe;
	}
	yui=0;
	loop(8){
		yudistx[yui]=cos(yuframe+yui*-45);
		yudisty[yui]=sin(yuframe+yui*-45);
		yui++;
	}

	yuframe++;
}

let yui=0;
let yuvisible=1;

function YumemiDrawLoop {

	SetTexture(imgYumemi);
	SetRenderState(ADD);
	SetColor(128,128,128);

	SetGraphicRect(130,128+(yuframe)%64,130+7,192+(yuframe)%64);
	yui=0;
	let newx;
	let newy;
	let prevx=cos(yuorbitangle1[yui+7]+yuframe*yuorbitrotspeed1[yui+7]*1.5)*110*yudistx[yui+7];
	let prevy=sin(yuorbitangle2[yui+7]+yuframe*yuorbitrotspeed2[yui+7]*1.5)*110*yudisty[yui+7];
	loop(8){
		newx=cos(yuorbitangle1[yui]+yuframe*yuorbitrotspeed1[yui]*1.5)*110*yudistx[yui];
		newy=sin(yuorbitangle2[yui]+yuframe*yuorbitrotspeed2[yui]*1.5)*110*yudisty[yui];
		SetGraphicScale(0.8,(distance(prevx,prevy,newx,newy)^0.5)/(64));
		SetGraphicAngle(0,0,atan2(newy-prevy,newx-prevx)+90);
		DrawGraphic(GetX+(prevx+newx)/2,GetY+(prevy+newy)/2);
		DrawGraphic(GetX-(prevx+newx)/2,GetY-(prevy+newy)/2);
		prevx=newx;
		prevy=newy;
		yui++;
	}


	SetGraphicAngle(0,0,0);
	SetGraphicScale(1,1);
	let percentage;
	loop(6){
		percentage=(yuframe-yuechot[yupose%6])/(5*6);
		SetColor(90-90*percentage,255-255*percentage,90-90*percentage);
		SetGraphicRect(yuechop[yupose%6]*64,1+128,yuechop[yupose%6]*64+64,127+128);
		DrawGraphic(yuechox[yupose%6]+yuechoxv[yupose%6]*percentage,yuechoy[yupose%6]+yuechoyv[yupose%6]*percentage);
		yupose++;
	}
	yupose-=6;

	if(yuvisible<1){
		SetColor(120*(1-yuvisible),120*(1-yuvisible),120*(1-yuvisible));
		SetGraphicRect(384,128,512,256);

		SetGraphicScale(1,1);
		SetGraphicAngle(0,0,yuframe*6);
		DrawGraphic(GetX,GetY);

		SetGraphicScale(0.7,0.7);
		SetGraphicAngle(0,0,yuframe*7.2);
		DrawGraphic(GetX,GetY);

		SetGraphicScale(0.3,0.3);
		SetGraphicAngle(0,0,yuframe*8.4);
		DrawGraphic(GetX,GetY);

		SetGraphicAngle(0,0,0);
		SetGraphicScale(1,1);
	}

	SetRenderState(ALPHA);
	SetColor(255,255,255);
	SetAlpha(yuvisible*255);
	SetGraphicRect(yupose*64+yuanim*256,1,yupose*64+64+yuanim*256,127);
	DrawGraphic(trunc(GetX),trunc(GetY+cos(yuframe*4)*2)-7);


	DrawFunctions;
}

task YumemiAttack(frames){
	yuanim=1;
	Wait(frames);
	yuanim=0;
}
task YumemiMove(frames){
	NewChargeShrink(frames,6,0.3,50,255,50);
	yuvisible=1;
	let fadeframes=5;
	if(frames<10){
		fadeframes=trunc(frames/2);
	}
	let frame=0;
	let alphaadd=1/fadeframes;
	loop(fadeframes){
		if(frame%4==0){
			YumemiEchoObj(GetX,GetY+(cos(yuframe*4)*2)-7,rand(0,1),rand(0,360));
		}
		frame++;
		yuvisible-=alphaadd;
		yield;
	}
	yuvisible=0;
	loop(frames-fadeframes*2){
		if(frame%4==0){
			YumemiEchoObj(GetX,GetY+(cos(yuframe*4)*2)-7,rand(0,1),rand(0,360));
		}
		frame++;
		yield;
	}
	loop(fadeframes){
		if(frame%4==0){
			YumemiEchoObj(GetX,GetY+(cos(yuframe*4)*2)-7,rand(0,1),rand(0,360));
		}
		frame++;
		yuvisible+=alphaadd;
		yield;
	}
	yuvisible=1;
}
task YumemiEchoObj(x,y,v,a){
	let obj=InitEffect(x,y,imgYumemi,4,ADD,2);
	ObjEffect_SetUVRect(obj,0,129,64,255);
	ObjEffect_SetXYRect(obj,-32,-63,32,63);

	let xv=cos(a)*v;
	let yv=sin(a)*v;

	let alpha=1;
	loop(60){
		Obj_SetColor(obj,4,128*alpha,255,255,255);
		Obj_SetPosition(obj,x,y);
		x+=xv;
		y+=yv;
		alpha-=1/60;
		yield;
	}
	Obj_Delete(obj);
}
function GetYuHandX{
	return GetX+9;
}
function GetYuHandY{
	return GetY-57;
}

function Gap(x1,y1,x2,y2,xw,yw,time,target){
	//target=[player,bullets]

	let obj1=Obj_Create(OBJ_EFFECT);
	let out1=Obj_Create(OBJ_EFFECT);
	let obj2=Obj_Create(OBJ_EFFECT);
	let out2=Obj_Create(OBJ_EFFECT);

	if(target[1]==1){
		gapi=gapi~[ [obj1,obj2] ];
		gapxw=gapxw~[xw];
		gapyw=gapyw~[yw];
	}
	Gap2(obj1,obj2,out1,out2,x1,y1,x2,y2,xw,yw,time,target);

	return [obj1,obj2,out1,out2];
}
task Gap2(obj1,obj2,out1,out2,x1,y1,x2,y2,xw,yw,time,target){

	DeleteCommonData("CloseGap");
	InitGap(obj1,out1,x1,y1,xw,yw,target[0]+target[1]*2);
	InitGap(obj2,out2,x2,y2,xw,yw,target[0]+target[1]*2);
	let xdist=0;
	let ydist=0;
	let warped=0;
	let k=0;
	Wait(30);
	while( (time>0&&target[1]==1) || (time>0&&warped==0&&target[1]==0) && GetCommonDataDefault("CloseGap",0)==0 ){

		x1=Obj_GetX(obj1);
		y1=Obj_GetY(obj1);
		x2=Obj_GetX(obj2);
		y2=Obj_GetY(obj2);

		if(target[0]==1){

			xdist=x1-GetPlayerX;
			ydist=y1-GetPlayerY;

			if(CollisionEllipse(GetPlayerX,GetPlayerY,x1,y1,xw/2,yw/2)==1&&warped==0){
				SetPlayerX(x2-xdist);
				SetPlayerY(y2-ydist);

				//GapLine(x1,y1,x2,y2);

				warped=1;
			}

			xdist=x2-GetPlayerX;
			ydist=y2-GetPlayerY;
			if(CollisionEllipse(GetPlayerX,GetPlayerY,x2,y2,xw/2,yw/2)==1&&warped==0){
				SetPlayerX(x1-xdist);
				SetPlayerY(y1-ydist);

				//GapLine(x2,y2,x1,y1);

				warped=1;
			}

		}

		time--;
		yield;
	}
	CloseGap(obj1,out1,xw,yw);
	CloseGap(obj2,out2,xw,yw);


}

task InitGap(obj,out,x,y,xw,yw,target){
	Obj_SetPosition(obj,x,y);
	Obj_SetPosition(out,x,y);



	ObjEffect_SetTexture(obj,imgGap);
	ObjEffect_CreateVertex(obj,gapvertices+2);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
	ObjEffect_SetVertexXY(obj,0,0,0);
	ObjEffect_SetLayer(obj,4);
	ObjEffect_SetLayer(out,4);

	ObjEffect_SetTexture(out,imgGap2);
	ObjEffect_CreateVertex(out,gapvertices*2+2);
	ObjEffect_SetPrimitiveType(out,PRIMITIVE_TRIANGLESTRIP);

	let k=0;

	FadeInGap(obj,out,xw,yw);

	let xscroll=rand(0,360);
	let yscroll=rand(0,256);
	let outlinescroll=rand(0,256);
	let outlinesegment=768/gapvertices;

	ObjEffect_SetVertexColor(obj,0,255,255,255,100);
	while(!Obj_BeDeleted(obj)){
		ObjEffect_SetVertexUV(obj,0,xscroll-cos(xscroll*4)*xw*0.5,yscroll-cos(yscroll*3)*yw*0.5);
		k=0;
		loop(gapvertices+1){
			ObjEffect_SetVertexUV(obj,k+1,(cosgap[k]*cosgap[k])*GetSign(cosgap[k])*xw*2+xscroll,singap[k]*yw*2+yscroll);

			ObjEffect_SetVertexUV(out,k*2,  outlinescroll+outlinesegment*k,50*target+49);
			ObjEffect_SetVertexUV(out,k*2+1,outlinescroll+outlinesegment*k,50*target+1);

			k++;
		}
		yscroll+=0.5+rand(-0.3,0.3);
		xscroll+=cos(yscroll*2)+rand(-0.5,0.5);
		outlinescroll+=3;
		yield;
	}


}
task FadeInGap(obj,out,xw,yw){

	let time=40;
	let width=lower(xw,yw)/4;

	let frame=0;
	loop(time){
		ResizeGap(obj,out,0,cos(center(0,frame,time)*(90/time)+270)*yw,width);
		frame++;
		yield;
	}
	frame=0;
	loop(time){
		ResizeGap(obj,out,cos(center(0,frame,time)*(90/time)+270)*xw,yw,width);
		frame++;
		yield;
	}
	ResizeGap(obj,out,xw,yw,width);
}
task CloseGap(obj,out,xw,yw){

	let time=30;
	let width=lower(xw,yw)/4;

	frame=0;
	loop(time){
		ResizeGap(obj,out,(1-cos(frame*(90/time)+270))*xw,yw,width);
		frame++;
		yield;
	}

	let frame=0;
	loop(time){
		ResizeGap(obj,out,0,(1-cos(frame*(90/time)+270))*yw,width);
		frame++;
		yield;
	}
	Obj_Delete(obj);
	Obj_Delete(out);
}

function ResizeGap(obj,out,xw,yw,width){
	let k=0;
	loop(gapvertices+1){
		ObjEffect_SetVertexXY(obj,k+1,cosgap[k]*xw,singap[k]*yw);

		ObjEffect_SetVertexXY(out,k*2,  cosgap[k]*(xw+width),singap[k]*(yw+width));
		ObjEffect_SetVertexXY(out,k*2+1,cosgap[k]*(xw),singap[k]*(yw));

		k++;
	}
}

task GapShot(x,y,v,a,g,d,threshold){
	let checkframe=round((5-v)/5)*5+1;

	let obj=Obj_Create(OBJ_SHOT);
	ObjShot_SetGraphic(obj,g);
	ObjShot_SetDelay(obj,d);
	Obj_SetPosition(obj,x,y);
	Obj_SetSpeed(obj,v);
	Obj_SetAngle(obj,a);

	let xdist=0;
	let ydist=0;
	let k=0;
	let x1=0;let x2=0;let y1=0;let y2=0;
	let gapdelay=0;
	let close=0;
	let closetime=0;
	while(!Obj_BeDeleted(obj)){
		if(gapdelay<=0){
			k=0;
			while(k<length(gapi)-1){
				x1=Obj_GetX(gapi[k+1][0]);
				y1=Obj_GetY(gapi[k+1][0]);
				x2=Obj_GetX(gapi[k+1][1]);
				y2=Obj_GetY(gapi[k+1][1]);
				xdist=Obj_GetX(obj);
				ydist=Obj_GetY(obj);

				if(close==0){
					if(distance(xdist,ydist,x1,y1)^0.5<upper(gapxw[k+1],gapyw[k+1])*1.5){	//use the more accurate, slow formula only if the bullet comes within a certain distance of the gap at some point
						close=1;
						closetime=120;
						checkframe=2;
					}
					else if(distance(xdist,ydist,x2,y2)^0.5<upper(gapxw[k+1],gapyw[k+1])*1.5){
						close=1;
						closetime=120;
						checkframe=2;
					}
				}

				if(close==1){
					if(CollisionEllipse(xdist,ydist,x1,y1,gapxw[k+1]*threshold,gapyw[k+1]*threshold)==1){
//						GapLineBullet(xdist,ydist,x2-(x1-xdist),y2-(y1-ydist),10,5,g);
						Obj_SetPosition(obj,x2-(x1-xdist),y2-(y1-ydist));
						gapdelay=(upper(gapxw[k+1],gapyw[k+1])*(threshold*2))/v;
						close=0;
						checkframe=round((5-v)/5)*5+1;
						closetime=0;
					}
					if(CollisionEllipse(xdist,ydist,x2,y2,gapxw[k+1]*threshold,gapyw[k+1]*threshold)==1){
//						GapLineBullet(xdist,ydist,x1-(x2-xdist),y1-(y2-ydist),10,5,g);
						Obj_SetPosition(obj,x1-(x2-xdist),y1-(y2-ydist));
						gapdelay=(upper(gapxw[k+1],gapyw[k+1])*(threshold*2))/v;
						close=0;
						checkframe=round((5-v)/5)*5+1;
						closetime=0;
					}
				}
				k++;
			}
		}
		if(closetime>0){
			closetime-=checkframe;
			if(closetime==0){
				close=0;
				checkframe=round((5-v)/5)*5+1;
			}
		}
		if(gapdelay>0){gapdelay-=checkframe;}
		Wait(checkframe);
	}

}
sub HandleGaps{
	let i=0;
	while(i<length(gapi)-1){
		if(Obj_BeDeleted(gapi[i+1][0])){
			gapi=erase(gapi,i+1);
			gapxw=erase(gapxw,i+1);
			gapyw=erase(gapyw,i+1);
//			gapt=erase(gapt,i+1);
			i--;
		}
		i++;
	}
}
function CrossShort{return 58;}
function CrossLong{return 99;}

let crosseffect=0;
sub LessenCrossEffect{
	crosseffect=1;
}

task Cross(x,y,time,delay){
	let effectintensity=1;
	if(crosseffect==1){
		crosseffect=0;
		effectintensity=0.5;
	}
	if(delay>0){
		CrossExplosion(x,y,   58,   12,delay*2,0, 0,255, 7);
		CrossExplosion(x,y+20,12,   79,delay*2,0, 0,255, 7);
		CrossExplosion(x,y,   58-12,0, delay*2,0, 0,120, 7);
		CrossExplosion(x,y+20,0,    67,delay*2,0, 0,120, 7);
	}

	loop(delay){yield;}


	SE("laser4");

	let startup=20;
	let decay=10;

	CrossCenter(x,y,20,time,20,0.5,-1,1);

	let obj=Obj_Create(OBJ_EFFECT);
	Obj_SetPosition(obj,x,y);
	ObjEffect_SetTexture(obj,imgYumemiCross);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
	ObjEffect_SetLayer(obj,4);
	ObjEffect_SetRenderState(obj,ADD);
	ObjEffect_CreateVertex(obj,4);
	ObjEffect_SetVertexXY(obj,0,-68,-68);
	ObjEffect_SetVertexXY(obj,1, 68,-68);
	ObjEffect_SetVertexXY(obj,2, 68,112);
	ObjEffect_SetVertexXY(obj,3,-68,112);
	ObjEffect_SetVertexUV(obj,0,60,60);
	ObjEffect_SetVertexUV(obj,1,196,60);
	ObjEffect_SetVertexUV(obj,2,196,240);
	ObjEffect_SetVertexUV(obj,3,60,240);

	let alpha=0;
	let red=0;
	let frame=0;
	let scale=1;
	loop(startup){
		red=225-sin(frame*80)*30;
		Obj_SetColor(obj,4,alpha,255,red,red);
		ObjEffect_SetScale(obj,1-sin(scale*90),1+scale);
		frame++;
		alpha+=255/startup;
		scale-=1/startup;
		yield;
	}

	ObjEffect_SetScale(obj,1,1);
	if(effectintensity==1){
		CrossExplosion(x,y,58,12,30,1, 1,255 ,5);
		CrossExplosion(x,y+20,12,79,30,1, 1,255, 5);
	}
	CrossExplosion(x,y+20,12,79,30,2, 1,255, 5);
	CrossExplosion(x,y,58,12,30,2, 1,255, 5);

	let grazed=0;
	loop(time){
		red=225-sin(frame*80)*30;
		Obj_SetColor(obj,4,255,255,red,red);
		frame++;
		if(frame%(5/effectintensity)==4){
			CrossExplosion(x+prand_int(-10,10),y+prand_int(-10,10),58,12,20,0, 1,128, 5);
			CrossExplosion(x+prand_int(-10,10),y+20+prand_int(-10,10),12,79,20,0, 1,128, 5);
		}
		if(grazed==0){
			grazed=RectGraze(x-70,y-23,x+70,y+23)*25;
		}
		if(grazed==0){
			grazed=RectGraze(x-23,y-70,x+23,y+112)*25;
		}
		if(grazed>0){grazed--;}
		RectCollision(x-50,y-8,x+50,y+8);
		RectCollision(x-8,y-50,x+8,y+92);

		yield;
	}
	loop(decay){
		red=225-sin(frame*80)*30;
		Obj_SetColor(obj,4,alpha,255,red,red);
		ObjEffect_SetScale(obj,1-sin(scale*90),1+scale);
		frame++;
		alpha+=255/decay;
		scale+=1/decay;
		yield;
	}
	Obj_Delete(obj);
}
task CrossCenter(x,y,startup,time,decay,size,dir,maxopacity){
	decay*=2;
	let obj=Obj_Create(OBJ_EFFECT);
	Obj_SetPosition(obj,x,y);
	ObjEffect_SetTexture(obj,imgYumemiCross);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
	ObjEffect_SetLayer(obj,4);
	ObjEffect_SetRenderState(obj,ADD);
	ObjEffect_CreateVertex(obj,4);
	ObjEffect_SetVertexXY(obj,0,-30,-30);
	ObjEffect_SetVertexXY(obj,1, 30,-30);
	ObjEffect_SetVertexXY(obj,2, 30, 30);
	ObjEffect_SetVertexXY(obj,3,-30, 30);
	ObjEffect_SetVertexUV(obj,0,0,0);
	ObjEffect_SetVertexUV(obj,1,60,0);
	ObjEffect_SetVertexUV(obj,2,60,60);
	ObjEffect_SetVertexUV(obj,3,0,60);

	let alpha=0;
	let red=0;
	let frame=0;
	let angle=0;
	let scale=3+size;
	loop(startup){
		red=225-sin(frame*80+180)*30;
		Obj_SetColor(obj,4,alpha*maxopacity,255,red,red);
		ObjEffect_SetAngle(obj,0,0,angle);
		ObjEffect_SetScale(obj,scale,scale);
		angle-=(3+scale*2)*dir;
		frame++;
		alpha+=255/startup;
		scale-=3/startup;
		yield;
	}
	ObjEffect_SetScale(obj,size,size);
	loop(time){
		red=225-sin(frame*80+180)*30;
		Obj_SetColor(obj,4,255*maxopacity,255,red,red);
		ObjEffect_SetAngle(obj,0,0,angle);
		angle-=4*dir;
		frame++;
		yield;
	}
	loop(decay){
		red=225-sin(frame*80+180)*30;
		Obj_SetColor(obj,4,alpha*maxopacity,255,red,red);
		ObjEffect_SetAngle(obj,0,0,angle);
		ObjEffect_SetScale(obj,scale,scale);
		angle-=(3+scale*2)*dir;
		frame++;
		alpha-=255/decay;
		scale+=3/decay;
		yield;
	}
	Obj_Delete(obj);
}
task CrossExplosion(x,y,width,height,expansiontime,sizeadd, color,alpha ,thickness){
	let k=0;
	let obj=[];
	loop(4){
		obj=obj~[Obj_Create(OBJ_EFFECT)];
		ObjEffect_SetTexture(obj[k],imgYumemiCross);
		ObjEffect_SetPrimitiveType(obj[k],PRIMITIVE_TRIANGLEFAN);
		ObjEffect_SetLayer(obj[k],4);
		ObjEffect_SetRenderState(obj[k],ADD);
		ObjEffect_CreateVertex(obj[k],4);
		ObjEffect_SetXYRect(obj[k],0,0,1,1);
		ObjEffect_SetUVRect(obj[k],99+color*10, 25, 109+color*10,27);
		k++;
	}
	ObjEffect_SetAngle(obj[2],0,0,90);
	ObjEffect_SetAngle(obj[3],0,0,90);
	let alphaadd=alpha/expansiontime;
	let frame=0;
	loop(expansiontime){
		CrossExplosionSetPosition(obj,round(x),round(y),width,height,alpha,thickness,frame%2);
		width+=sizeadd;
		height+=sizeadd;
		alpha-=alphaadd;
		frame++;
		yield;		
	}
	k=0;
	loop(4){
		Obj_Delete(obj[k]);
		k++;
	}
}
function CrossExplosionSetPosition(obj,x,y,width,height,alpha,thickness,adjustalpha){
	Obj_SetPosition(obj[0],x+width,y);
	Obj_SetPosition(obj[1],x-width,y);
	Obj_SetPosition(obj[2],x,y-height);
	Obj_SetPosition(obj[3],x,y+height);
	ObjEffect_SetScale(obj[0],thickness,height*2);
	ObjEffect_SetScale(obj[1],thickness,height*2);
	ObjEffect_SetScale(obj[2],thickness,width*2);
	ObjEffect_SetScale(obj[3],thickness,width*2);
	if(adjustalpha==0){
		let k=0;
		loop(4){
			Obj_SetColor(obj[k],4,alpha,255,255,255);
			k++;
		}
	}
}





sub YukariInit{
	CreateRenderTarget("yukarigap",256,256);
	ClearRenderTarget("yukarigap");

	let k=0;
	loop(gapvertices+1){
		cosgap=cosgap~[cos(k*(360/gapvertices)-90)];
		singap=singap~[sin(k*(360/gapvertices)-90)];
		k++;
	}

}
sub YukariFinalize{
	DeleteGraphic("yukarigap");
}
sub YumemiInit{
	yuframe=rand_int(100,5000);
}
sub YumemiFinalize{
}
