#include_function ".\..\playerselect.txt"
#include_function ".\..\tutorial.txt"

 let diffBG=GPSD~"img\diffbg.png";
 let diffBG2=GPSD~"img\menu.png";
 let diffBG3=GPSD~"img\clouds2.png";
 let diffTitle=GPSD~"img\title.png";
 let diffLeafB=GPSD~"img\leafbig.png";
 let diffLeafS=GPSD~"img\leafsmall3.png";
 let diffText=GPSD~"img\difficulty.png";
 let diffStars=GPSD~"img\stars.png";
 let imgSelector=GPSD~"img\selector.png";
 let imgStatbox=GPSD~"img\statbox.png";
 let imgCharselect=GPSD~"img\charselect.png";
 let imgCharnames=GPSD~"img\playernames.png";

 let titlemusic=GetCurrentScriptDirectory~"..\music\0";

 let menucancel=0;
 let menumove=0;
 let menuanimate=1;
 let menuselectable=1;

function InitObjects{
	let kk=0;
	loop(50){
		objects=objects~[CreateObject];
		if(kk==12){
			loop(3){
				DrawTitleShadow;
			}
		}
		if(kk==LeafLayer){InitLeaves(0,NumLeaves);}
		kk++;
	}
}
task LoadMenus{
	LoadGraphic(diffBG);
	LoadGraphic(diffBG2);
	LoadGraphic(diffBG3);
	LoadGraphic(diffTitle);
	LoadGraphic(diffLeafB);
	LoadGraphic(diffLeafS);
	LoadGraphic(diffText);
	LoadGraphic(imgText);
	LoadGraphic(imgSelector);
	LoadGraphic(imgStatbox);
	LoadGraphic(imgCharselect);
	LoadGraphic(imgCharnames);
	LoadGraphic(imgSoundThing);
	ForbidShot2(true);
	LoadMusic(titlemusic);
	PlayMusic(titlemusic);
	mstarttime=GetTime;
	loop(upper((1-menuanimate)*24,1)){yield;}
}

task CreateMenu(items,cancellable,loops){
	menuselectable=1;
	InMenu=1;
	diffselect=0;
	menuitem=0;
	menumove=0;
	let delay=0;
	while(diffselect==0){
		yield;
		if(menumove==1){
			if(GetKeyState(VK_UP)==KEY_PUSH&&(loops==1||menuitem>0)){menuitem--;SE("select");delay=3;}
			if(GetKeyState(VK_DOWN)==KEY_PUSH&&(loops==1||menuitem<items-1)){menuitem++;SE("select");delay=3;}
		}
		if(loops==1){
			if(menuitem<0){menuitem+=items;}
			if(menuitem>=items){menuitem-=items;}
		}else{
			if(menuitem<0){menuitem=0;}
			if(menuitem>=items){menuitem=items-1;}
		}
		if(menumove==1&&delay<0){
			if(GetKeyState(VK_SHOT)==KEY_PUSH){
				yield;
				if(menuselectable==1){
					diffselect=1;
					menucancel=0;
					SE("ok");
				}
			}
			if(GetKeyState(VK_BOMB)==KEY_PUSH&&cancellable==1){
				diffselect=1;
				menucancel=1;
				SE("cancel");
			}
		}
		delay--;
	}
	SetPlayerY(400);
	SetPlayerX(GetCenterX);
	InMenu=0;
}

function EndMenu{
	loop(50){
		Obj_Delete(objects[0]);
		objects=erase(objects,0);
	}
	loop(NumLeaves){
		Obj_Delete(leaves[0]);	
		leaves=erase(leaves,0);
	}
	Wait(600);
	DeleteGraphic(diffBG);
	DeleteGraphic(diffBG2);
	DeleteGraphic(diffBG3);
	DeleteGraphic(diffTitle);
	DeleteGraphic(diffLeafB);
	DeleteGraphic(diffLeafS);
	DeleteGraphic(diffText);
	DeleteGraphic(imgSelector);
	DeleteGraphic(imgStatbox);
	DeleteGraphic(imgCharselect);
	DeleteGraphic(imgCharnames);
	DeleteGraphic(imgSoundThing);
	DeleteGraphic("targetSparkles");
	DeleteGraphic("targetSparkles2");
	if(GameMode<3){ForbidShot2(false);}
}

task FadeWhite(a1,a2,time){
//loading screen
	time-=3;

	let loadtype=trunc(GetCommonDataDefault("Random2",0))%4;
	let loadcolor=(GetCommonDataDefault("Random2",0))*74;
	let loadmisc=(GetCommonDataDefault("Random2",0))*1000000;
	if(a2>0){
		loadtype=trunc(GetCommonDataDefault("Random",0))%4;
		loadcolor=(GetCommonDataDefault("Random",0))*74;
		loadmisc=(GetCommonDataDefault("Random",0))*1000000;
	}


	loadtype=0;

	let obj;	//white bg
	let obj2;	//stars
	let obj3;	//character
	let obj4;	//"loading..."
	let loops=1;
	if(a1>128){loops++;}

	let subtracta=(a1-a2)/time;
	let obj3angle=-100-(loadmisc%20);
	let tn=400;
	let tempangle=atan2(-640,-480);
	let loadingangles=[180-tempangle,-180+tempangle,-tempangle,tempangle];

	while(loops>0){
		obj=InitEffect(320,GetCenterY,stgwhite,4,ADD,8);
		ObjEffect_SetXYRect(obj,-400,-300,400,300);
		ObjEffect_SetUVRect(obj,0,0,10,10);

		obj3=InitEffect(0,0,imgLoading2,4,ALPHA,8);
		ObjEffect_SetXYRect(obj3,0,0,640,480);

		ObjEffect_SetVertexUV(obj3,0,cos(obj3angle+loadingangles[0])*tn+loadmisc%256,sin(obj3angle+loadingangles[0])*tn+trunc(loadmisc/256)%256);
		ObjEffect_SetVertexUV(obj3,1,cos(obj3angle+loadingangles[1])*tn+loadmisc%256,sin(obj3angle+loadingangles[1])*tn+trunc(loadmisc/256)%256);
		ObjEffect_SetVertexUV(obj3,2,cos(obj3angle+loadingangles[2])*tn+loadmisc%256,sin(obj3angle+loadingangles[2])*tn+trunc(loadmisc/256)%256);
		ObjEffect_SetVertexUV(obj3,3,cos(obj3angle+loadingangles[3])*tn+loadmisc%256,sin(obj3angle+loadingangles[3])*tn+trunc(loadmisc/256)%256);
	
		obj2=InitEffect(640,480,imgLoading,4,ALPHA,8);
		ObjEffect_SetXYRect(obj2,-150,-150,0,0);
		ObjEffect_SetUVRect(obj2,loadtype*150,0,loadtype*150+150,150);
		ObjEffect_SetScale(obj2,1.2,1.2);

		obj4=InitEffect(0,480,imgLoading,4,ALPHA,8);
		ObjEffect_SetXYRect(obj4,0,-34,100,0);
		ObjEffect_SetUVRect(obj4,0,150,128,184);

		Obj_SetColor(obj, 4,255-cos(a1*(90/255))*255,255,255,255);
		Obj_SetColor(obj2,4,255-cos(a1*(90/255))*255,Rainbow(0,loadcolor)*90,Rainbow(1,loadcolor)*90,Rainbow(2,loadcolor)*90);
		SetLoadingBG(obj3,a1,loadcolor);
		Obj_SetColor(obj4,4,255-cos(a1*(90/255))*255,Rainbow(0,loadcolor)*70+180,Rainbow(1,loadcolor)*70+180,Rainbow(2,loadcolor)*70+180);
		SetCommonData("FadeBurst",a1/255);

		yield;
		if(loops>1){
			Obj_Delete(obj);
			Obj_Delete(obj2);
			Obj_Delete(obj3);
			Obj_Delete(obj4);
		}
		loops--;
	}
	yield;
	let ka=0;
	let frame=0;

	loop(time){
		Obj_SetColor(obj, 4,255-cos(a1*(90/255))*255,255,255,255);
		Obj_SetColor(obj2,4,255-cos(a1*(90/255))*255,Rainbow(0,loadcolor)*90,Rainbow(1,loadcolor)*90,Rainbow(2,loadcolor)*90);
		SetLoadingBG(obj3,a1,loadcolor);
		Obj_SetColor(obj4,4,255-cos(a1*(90/255))*255,Rainbow(0,loadcolor)*90+150,Rainbow(1,loadcolor)*90+150,Rainbow(2,loadcolor)*90+150);
		SetCommonData("FadeBurst",a1/255);
		a1=a1-subtracta;
		yield;
	}
	ka=0;
	loop(4){
		ObjEffect_SetVertexColor(obj, ka,a2,255,255,255);
		ObjEffect_SetVertexColor(obj2,ka,a2,Rainbow(0,loadcolor)*90,Rainbow(1,loadcolor)*90,Rainbow(2,loadcolor)*90);
		ka++;
	}
	if(a2==255){
		ObjEffect_SetRenderState(obj,ALPHA);
	}
	SetCommonData("FadeBurst",a2/255);
	SetLoadingBG(obj3,a2,loadcolor);
	Wait(10);
	Obj_Delete(obj);
	Obj_Delete(obj2);
	Obj_Delete(obj3);
	Obj_Delete(obj4);
}
function SetLoadingBG(obj,a1,loadcolor){
	let alpha=255-cos(a1*(90/255))*255;
	ObjEffect_SetVertexColor(obj,0,alpha,Rainbow(0,loadcolor+180)*120,Rainbow(1,loadcolor+180)*120,Rainbow(2,loadcolor+180)*120);
	ObjEffect_SetVertexColor(obj,1,alpha,Rainbow(0,loadcolor+90)*90,Rainbow(1,loadcolor+90)*90,Rainbow(2,loadcolor+90)*90);
	ObjEffect_SetVertexColor(obj,2,0,0,0,0);
	ObjEffect_SetVertexColor(obj,3,alpha,Rainbow(0,loadcolor-90)*90,Rainbow(1,loadcolor-90)*90,Rainbow(2,loadcolor-90)*90);
}

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

//0-19

let leafx=[];
let leafy=[];
let leafs=[];
let leafr=[];
let leafr2=[];
let leaft=[];
let leaff=[];
let leafc=[];
let leaves=[];

function InitLeaf(ind){
		let color1=55;	//base
		let color2=50;	//max add

		leafx[ind]=rand_int(-50,690);
		leafy[ind]=rand_int(-100,400);
		leafr[ind]=rand(-4,4);
		leafr2[ind]=rand_int(0,360);
		leafs[ind]=rand(0.5,1.5);
		leaff[ind]=rand(0,100);
		let color=rand_int(0,360);
		leafc[ind]=[rainbow(0,color)*color2+color1,rainbow(1,color)*color2+color1,rainbow(2,color)*color2+color1];
		leaft[ind]=0;
}
function InitLeaves(ind1,ind2){
	let ind3=0;
	loop(ind2-ind1){
		leafx=leafx~[0]; leafy=leafy~[0]; leafs=leafs~[0]; leafr=leafr~[0]; leaff=leaff~[0]; leafr2=leafr2~[0]; leaft=leaft~[0]; leafc=leafc~[[0,0,0]]; leaves=leaves~[0]; 

		leaves[ind3]=CreateObject;
		InitLeaf(ind3);
		leaft[ind3]=prand_int(0,200);
		ind3++;
	}
}

let LeafLayer=7;	//what object they're drawn after
let NumLeaves=30;

function DrawLeaves(ind1,ind2,ddi,opacity,change){
	change/=16.666667;
	change=lower(change,4);
	opacity/=250;
	let ind3=0;
	let alpha=0;
	loop(ind2-ind1){
		if(leaft[ind3]<40){alpha=(160-(40-leaft[ind3])*4);}
		else if(leaft[ind3]>160){alpha=((200-leaft[ind3])*4);}
		else{alpha=160;}
		alpha=center(0,alpha,255);
		leafy[ind3]=leafy[ind3]+leafs[ind3]*change;
		leaft[ind3]=leaft[ind3]+1;
		if(leaft[ind3]>=200){InitLeaf(ind3);}
		DrawObject(leaves[ind1],diffLeafS,0,0,128,128,leafx[ind3]+sin((ddi+leafr2[ind3])*1.5)*leaff[ind3],leafy[ind3],0.5,0.5,ADD,alpha*opacity,8,leafc[ind3][0],leafc[ind3][1],leafc[ind3][2],0,0,leafr[ind3]*ddi+leafr2[ind3]);
		ind1++;
		ind3++;
	}
}

let kanjix=[80,200,110,210,310];
let kanjiy=[140,120,410,390,370];
let titleinit=0;
sub TitleStatic{
	DrawObject(objects[14],diffTitle,0,0,950,60, 290,180, 1.4-0.7,0.7,ALPHA,255,8,255,255,255,0,0,-30);

	let num=0;
	loop(5){
		DrawObject(objects[15+num],diffTitle,150*num,60,150*(num+1),200, kanjix[num],kanjiy[num], 1,1,ALPHA,250,8,255,255,255,0,0,-10);
		num++;
	}
	titleinit=1;
}

task TitleBegin{
	let frame=0;
	let num=0;
	loop(5){
		KanjiIntro(num);
		num++;
		loop(4){yield;}
	}

	let time=14;
	loop(time){
		frame++;
		DrawObject(objects[14],diffTitle,0,0,950,60, 290,180, 1.4-(frame/time)*0.7,0.7*(frame/time),ALPHA,frame*(255/time),8,255,255,255,0,0,-30);
		yield;
	}
	titleinit=1;
}
task KanjiIntro(num){
	let frame=0;
	let time=20;
	let time2=50;
	loop(time){
		frame++;
		DrawObject(objects[15+num],diffTitle,150*num,60,150*(num+1),200, kanjix[num],kanjiy[num], 10-(frame/time)*9,10-(frame/time)*9,ALPHA,frame*(250/time),8,255,255,255,0,0,-10-(time-frame)*4);
		yield;
	}
	frame=0;
	loop(time2){
		frame++;
		DrawObject(objects[9+num],diffTitle,150*num,60,150*(num+1),200, kanjix[num],kanjiy[num], 1+(frame/time)*1,1+(frame/time)*1,ALPHA,(250-(frame*(250/time2)))*0.8,8,255,255,255,0,0,-10);
		yield;
	}
}

task MenuBG{
	let kanjimax=0;
	let kanjimult=[1,0.9,1.2,0.8,1.3];

	let objcircle1=-1;
	let objcircle2=-1;
	DeleteCommonData("FadeBG");
	let bgopacity=10;
	let ddi=rand(0,360);
	if(menuanimate==1){
		TitleBegin;
		menuanimate=0;
		bgopacity=250;
	}else if(menuanimate==2){bgopacity=250;TitleStatic;}

	CreateRenderTarget("targetSparkles",512,512);
	CreateRenderTarget("targetSparkles2",512,512);
	HandleSparkles;
	let LastTime=GetTime;
	while(bgopacity>0){
		DrawObject(objects[0],diffBG,0+ddi/2,0,484/1.5+ddi/2,644/2,320,0,4,4,ALPHA,(bgopacity+5),8,155,155,155,0,0,45);
		DrawObject(objects[1],diffBG,0+ddi,0,644/2+ddi,484/2,320,240,4,4,ALPHA,(bgopacity+5)*0.6,8,155,155,155,0,0,0);
		DrawObject(objects[2],"targetSparkles",0,0,512,512,320,240,1.5,1.5,ADD,(bgopacity)*0.4,8,255,255,255,0,0,0);
		DrawObject(objects[29],"targetSparkles",0,0,512,512,320,240,1.5,1.5,ADD,(bgopacity)*0.2,8,255,255,255,0,0,0);

		DrawObject(objects[4],diffTitle,0,210,155,  256, 175, 20,1,1,ALPHA,200,8,255,255,255,0,0,sin(ddi*2)*3);
		DrawObject(objects[5],diffTitle,165,210,280,256, 55,30,1,1,ALPHA,200,8,255,255,255,0,0,sin(ddi*2+120)*3);
		DrawObject(objects[6],diffTitle,290,210,415,256, 55,10,1,1,ALPHA,200,8,255,255,255,0,0,sin(ddi*2+240)*3);

		DrawObject(objects[7],diffTitle,430,210,510,256, 620,23,0.75,0.75,ALPHA,235,8,255,255,255,0,0,0);

		objcircle1=CenterCircleMenu(objcircle1,0,0+ddi*4,2560,200+ddi*4,120,240,700,48,ddi/10,8,(bgopacity/2)*(1-GetCommonDataDefault("FadeBurst",0)),ADD,255,255,255);
//		objcircle2=CenterCircleMenu(objcircle2,0,0-ddi*3,2560,100-ddi*3,120,240,700,48,-ddi/10,8,(bgopacity/4)*(1-GetCommonDataDefault("FadeBurst",0)),SUBTRACT,255,255,255);

		DrawObject(objects[8],diffLeafB,0,0,256,256,202,240,1.5,-1.5,ALPHA,(bgopacity+5),8,rainbow(0,ddi)*15,rainbow(1,ddi)*15,rainbow(2,ddi)*15,0,0,-150);

		if(titleinit>0){DrawObject(objects[14],diffTitle,0,0,950,60, 290,180, 0.7,0.7,ALPHA,bgopacity+5,8,255,255,255,0,0,-30);}

		i=0;
		loop(5){
			if(titleinit>0){DrawObject(objects[15+i],diffTitle,150*i,60,150*(i+1),200, kanjix[i],kanjiy[i], 1,1,ALPHA,bgopacity+5,8,255,255,255,0,0,-10+sin(ddi*kanjimult[i])*5*kanjimax);}
			i++;
		}
		kanjimax=lower(kanjimax+0.008,1);

//		if(GetCommonDataDefault("FadeBG",0)==1){bgopacity-=2;if(menuanimate==2){bgopacity-=8;}}
//		else if(bgopacity<250){bgopacity+=20;}
		ddi+=(GetTime-LastTime)/30;
		DrawLeaves(0,NumLeaves,ddi,bgopacity,(GetTime-LastTime));
		LastTime=GetTime;
		yield;
	}
	DeleteCommonData("FadeBG");
	loop(10){yield;}
	EndMenu;
}
task HandleSparkles{

	let x=[0,0,0,0,0,0,0];
	let y=[0,0,0,0,0,0,0];

	let xmult=[1.0,1.3,1.7,1.4,1.8,1.9,1.5];
	let ymult=[1.3,1.5,1.8,1.4,1.5,1.2,1.9];

	let prevtarget;
	let frame=rand_int(1000,2000);
	let k=0;
	let angle;
	let dist;
	let size;
	let frame2=0;

	let numedges=5;
	let numloops=15;

	let color=[0,0,0];
	let effect=rand_int(0,7);
	loop{
		loop(numloops){
			prevtarget=SetRenderTarget("targetSparkles2");
			ClearRenderTarget("targetSparkles2");

			SetTexture("targetSparkles");
			SetGraphicRect(0,0,512,512);
			SetGraphicAngle(0,0,0);
			SetGraphicScale(1,1);
			SetColor(255,255,255);
			DrawGraphic(256,256);

			SetRenderTarget("targetSparkles");
			ClearRenderTarget("targetSparkles");

			SetTexture("targetSparkles2");
			color=RainbowArray(frame*2,4,249);
			SetColor(color[0],color[1],color[2]);
			AddEffect(effect);

			DrawGraphic(256,256);

			SetTexture(imgEffects);
			SetGraphicRect(128,1,191,63);
			SetRenderState(ADD);
			SetColor(100,100,100);

			frame+=0.1;
			k=0;
			loop(numedges){
				x[k]=sin(frame*xmult[k]+k*(360/numedges))*240;
				y[k]=sin(frame*ymult[k]+k*(360/numedges))*240;
				k++;
			}
			k=0;
			loop(numedges){
				angle=atan2(y[(k+1)%numedges]-y[k],x[(k+1)%numedges]-x[k]);
				dist=distance(x[k],y[k],x[(k+1)%numedges],y[(k+1)%numedges])^0.5;
				let something=(frame/20)%1;
				loop(2){
					size=rand(0.5,1)*1.2;
					SetGraphicAngle(0,0,rand(0,360));
					SetGraphicScale(size,size);

					DrawGraphic( (x[k]+cos(angle)*dist*something)+256, (y[k]+sin(angle)*dist*something)+256);
					DrawGraphic(-(x[k]+cos(angle)*dist*something)+256, (y[k]+sin(angle)*dist*something)+256);
					DrawGraphic(-(x[k]+cos(angle)*dist*something)+256,-(y[k]+sin(angle)*dist*something)+256);
					DrawGraphic( (x[k]+cos(angle)*dist*something)+256,-(y[k]+sin(angle)*dist*something)+256);

					something=(something+0.5)%1;
				}
				k++;
			}

			SetRenderTarget(prevtarget);
		}
		frame2++;
		numloops=1;
		yield;
	}
	function AddEffect(effect){
		if(effect==0){
			SetGraphicScale(1,1.015);SetGraphicAngle(0,0,0);
		}else if(effect==1){
			SetGraphicScale(1.015,1);SetGraphicAngle(0,0,0);
		}else if(effect==2){
			SetGraphicScale(1,1);SetGraphicAngle(0,0,0.2*(frame2%2));
		}else if(effect==3){
			SetGraphicScale(1,1);SetGraphicAngle(0,0,-0.2*(frame2%2));
		}else if(effect==4){
			SetGraphicScale(1,1);SetGraphicAngle(1,0,0);
		}else if(effect==5){
			SetGraphicScale(1,1);SetGraphicAngle(-1,0,0);
		}else if(effect==6){
			SetGraphicScale(1,1);SetGraphicAngle(0,1,0);
		}else if(effect==7){
			SetGraphicScale(1,1);SetGraphicAngle(0,-1,0);
		}
	}
}

function FadeMenuBG{
	SetCommonData("FadeBG",1);
}


function CenterCircleMenu(obj,left,top,right,bottom,centerX,centerY,radius,segments,rotation,layer,alpha,renderstate,red,green,blue){
//graphic,left,top,right,bottom,centerX,centerY,radius,segments,rotation,layer,alpha,renderstate,red,green,blue

    if(obj==-1){
	obj = Obj_Create(OBJ_EFFECT);
	Obj_SetPosition   (obj, centerX,centerY);
	Obj_SetSpeed      (obj, 0);
	Obj_SetAngle(obj, 0);
	ObjEffect_SetTexture(obj,diffBG3);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLESTRIP);
	ObjEffect_CreateVertex(obj,(segments*2)+2);
	ObjEffect_SetScale(obj,1,1);
	ObjEffect_SetLayer(obj,layer);
	ObjEffect_SetRenderState(obj,renderstate);
    }
    let n=0;

    ObjEffect_SetAngle(obj,0,0,rotation);

    n=0;
    loop((segments*2)+2){
	if(n%2==0){
		ObjEffect_SetVertexUV(obj,n,left+(right/segments)*floor(n/2),top);
		ObjEffect_SetVertexXY(obj,n, cos((360/segments)*floor(n/2))*radius, sin((360/segments)*floor(n/2))*radius );
		ObjEffect_SetVertexColor(obj,n,0,red,green,blue);
	} else {
		ObjEffect_SetVertexUV(obj,n,left+(right/segments)*floor(n/2),bottom);
		ObjEffect_SetVertexXY(obj,n,0,0);
		ObjEffect_SetVertexColor(obj,n,alpha,red,green,blue);
	}
	n++;
    }
    return obj;
}

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

//20-28

function DifficultySelect(allowarray){

	let cchoice=0;	//int
	while(!allowarray[cchoice%4]){
		cchoice++;
	}

	let exit1=false;	//exit menu
	let exit2=false;	//delete objects
	DifficultySelect2(allowarray);
	while(!exit1){yield;}

	return cchoice;

task DifficultySelect2(allowarray){

	let xk1=[410,440,460,440];	//stage name
	let yk1=[160,260,350,260];
	let xk2=[410,440,464,440];	//glowy thing
	let yk2=[160,260,346,260];


	let c1=[255,120,200,120];

	let diffcolorr=[150,250,255];
	let diffcolorg=[255,255,210];
	let diffcolorb=[150,150,100];


	let cchoiced=cchoice;	//decimal
	let ddu=0;
	let alpha=0;
	InMenu=1;
	let exitpercent=0;
	let totalalpha=0;
	let menucancel2=0;
	while(!exit2){
		//id,graphic,left,top,right,bottom,centerX,centerY,scalex,scaley,renderstate,alpha,layer,c1,c2,c3,r1,r2,r3
		k=0;
		totalalpha=alpha*(1-exitpercent);
		loop(4){
			if(allowarray[k]){
				DrawObject(objects[23+k],diffText,1,k*96+1,169,k*96+95,xk1[k]+80,yk1[k]+40, 1,1,ALPHA,200*(1-exitpercent),8,170,170,170,0,0,0);
				if(k==cchoiced){
					DrawObject(objects[20],diffText,256-128,512-128,256,512, xk2[k]+78,yk2[k]+38 ,1.5+exitpercent*13*(1-menucancel2),1.5+exitpercent*2,ADD,totalalpha*255,8,c1[0],c1[1],c1[2],ddu*2,-ddu*3,ddu*4);
					DrawObject(objects[21],diffText,256-128,512-128,256,512, xk2[k]+78,yk2[k]+38 ,1.5+exitpercent*13*(1-menucancel2),1.5+exitpercent*2,ADD,totalalpha*255,8,c1[1],c1[2],c1[0],ddu*2+60,-ddu*3+120,ddu*4);
					DrawObject(objects[22],diffText,256-128,512-128,256,512, xk2[k]+78,yk2[k]+38 ,1.5+exitpercent*13*(1-menucancel2),1.5+exitpercent*2,ADD,totalalpha*255,8,c1[2],c1[0],c1[1],ddu*2+120,-ddu*3+60,ddu*4);

					//DrawObject(objects[27],diffText,0,326,110,346,xk2[k]-40,yk2[k],sk2[k]+exitpercent*10,exitpercent*3+1,ALPHA,totalalpha*255,8,255,255,255,0,0,0);
					DrawObject(objects[28],diffText,1,k*96+1,169,k*96+95,xk1[k]+80-2,yk1[k]+40-2, 1,1,ALPHA,totalalpha*(235+sin(ddu*20)*20),8,255,255,255,0,0,0);
				}
			}
			k++;
		}
		if(!exit1){
			if(GetKeyState(VK_DOWN)==KEY_PUSH){
				cchoice++;
				while(!allowarray[cchoice%4]){
					cchoice++;
				}
				SE("select");
				cchoice%=4;
			}else if(GetKeyState(VK_UP)==KEY_PUSH){
				cchoice--;
				while(cchoice<0){cchoice+=4;}
				while(!allowarray[cchoice%4]){
					cchoice--;
					while(cchoice<0){cchoice+=4;}
				}
				SE("select");
				while(cchoice<0){cchoice+=4;}
				cchoice%=4;
			}
			if(GetKeyState(VK_SHOT)==KEY_PUSH){
				menucancel=0;
				exit1=true;
				SE("ok");
			}else if(GetKeyState(VK_BOMB)==KEY_PUSH){
				menucancel=1;
				menucancel2=1;
				exit1=true;
				SE("cancel");
			}
		}
		if(exit1){
			if(exitpercent==1){
				exit2=true;
			}
			exitpercent+=1/60;
			if(exitpercent>=1){
				exitpercent=1;
			}
		}
		if(cchoiced!=cchoice){
			if(alpha<=0){
				cchoiced=cchoice;
				alpha=0;
			}else{
				alpha-=1/5;
			}
		}else if(alpha<1){alpha+=1/5;}

		ddu+=0.5;
		yield;
	}
}
}

let ddo=rand_int(0,360);




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

//30-32

let stagec1=[70,70,70,250,250,250,0,0,0,250,250,250];
let stagec2=[70,250,250,250,70,70,0,0,0,250,250,250];
let stagec3=[250,250,70,70,70,250,0,0,0,250,250,250];
let stagetext=["Stage 1","Stage 2","Stage 3","","","","","","","Extra Stage 1","Extra Stage 2","Extra Stage 3"];
let stagedescription=["Spring of a Clouded World","Artery of Stone","Border of Gensokyo","","","","","","","Angel of Dreams","Master of the Elements","Seven-Colored Puppeteer"];

function StageSelect{
	let uniquechoices=0;	//the number of stages available
	let ddu=0;
	let choicelist=[];
	loop(13){
		if(IsSeenStageAll(ddu)){
			choicelist=choicelist~[ddu];
			uniquechoices++;
		}
		ddu++;
	}

	let numchoices=uniquechoices;
	if(uniquechoices==1){
		numchoices=4;
	}else if(uniquechoices==2||uniquechoices==3){
		numchoices=6;
	}else if(uniquechoices==4){
		numchoices=8;
	}
	let wheelradius=upper(100,numchoices*15);
	CreateMenu(numchoices,1,1);
	InMenu=2;
	ddu=0;
	let ctext=0;
	SetFontStyle(1,3,0,0,1,10);
	SetFontColorNew(100,100,100,170,170,170);
	let obj=[];
	let objlen=[];
	let obj2=[];
	let objlen2=[];
	let rotation=menuitem;
	loop(numchoices){
		obj=obj~[DrawTextNewObj(2,stagetext[choicelist[ddu%uniquechoices]],imgText,480,sin(WheelPos(ddu,rotation,numchoices))*wheelradius+300,0,5,5,8,0,205,1)];
		objlen=objlen~[length(stagetext[choicelist[ddu%uniquechoices]])];
		obj2=obj2~[DrawTextBoldObj(2,stagedescription[choicelist[ddu%uniquechoices]],imgText,480,sin(WheelPos(ddu,rotation,numchoices))*wheelradius+300,0,3.3,3.1,8,0,205,1)];
		objlen2=objlen2~[length(stagedescription[choicelist[ddu%uniquechoices]])];
		ddu++;
	}
	ddu=0;
	let inmenusave=0;
	ctext=1;
	let selectobj;
	let selectobj2;
	while(InMenu==2){
		if(ctext!=menuitem){
			ClearTextImmediately(3);
			yield;
			yield;
			yield;
			ClearTextImmediately(3);
			ctext=menuitem;
			SetFontColorNew(255,255,255,stagec1[choicelist[menuitem%uniquechoices]],stagec2[choicelist[menuitem%uniquechoices]],stagec3[choicelist[menuitem%uniquechoices]]);
			SetFontStyle(0,0,0,0,0,0);
			selectobj=DrawTextNewObj(3,stagetext[choicelist[menuitem%uniquechoices]],imgText,480,sin(WheelPos(menuitem,rotation,numchoices))*wheelradius+300,0,5,5,8,0,255,0);
			selectobj2=DrawTextNewObj(3,stagedescription[choicelist[menuitem%uniquechoices]],imgText,480,sin(WheelPos(menuitem+0.4,rotation,numchoices))*wheelradius+300,0,3.3,3.1,8,0,255,0);
			if(choicelist[menuitem%uniquechoices]>=9){
				ExtraStageRainbow(selectobj,length(stagetext[choicelist[menuitem%uniquechoices]]),choicelist[menuitem%uniquechoices]-9);
				ExtraStageRainbow(selectobj2,length(stagedescription[choicelist[menuitem%uniquechoices]]),choicelist[menuitem%uniquechoices]-9);
			}
			menumove=1;
		}


		ddu=0;
		loop(numchoices){
			Obj_SetPosition(obj[ddu],480,sin(WheelPos(ddu,rotation,numchoices))*wheelradius+300 );
			Obj_SetColor(obj[ddu],objlen[ddu%uniquechoices]*6,upper(0,cos(WheelPos(ddu,rotation,numchoices))*200),255,255,255);

			Obj_SetPosition(obj2[ddu],480,sin(WheelPos(ddu+0.4,rotation,numchoices))*wheelradius+300 );
			Obj_SetColor(obj2[ddu],objlen2[ddu%uniquechoices]*6,upper(0,cos(WheelPos(ddu+0.4,rotation,numchoices))*200),255,255,255);

			ddu++;
		}

		Obj_SetPosition(selectobj,480,sin(WheelPos(menuitem,rotation,numchoices))*wheelradius+300 );
		Obj_SetPosition(selectobj2,480,sin(WheelPos(menuitem+0.4,rotation,numchoices))*wheelradius+300 );

		if(rand_int(0,2)==0){
			Sparkle(480+rand(-objlen[menuitem]*8,objlen[menuitem]*8),sin(WheelPos(menuitem,rotation,numchoices))*wheelradius+300+rand(-12,12),  0.2,rand(0,360),0.5,60,80);
		}else{
			Sparkle(480+rand(-objlen2[menuitem]*5.5,objlen2[menuitem]*5.5),sin(WheelPos(menuitem+0.4,rotation,numchoices))*wheelradius+300+rand(-12,12),  0.2,rand(0,360),0.5,60,80);
		}
		if(absolute((menuitem+numchoices)-rotation)<absolute(menuitem-rotation)){
			rotation+=((menuitem+numchoices)-rotation)/numchoices;
		}else if(absolute((menuitem-numchoices)-rotation)<absolute(menuitem-rotation)){
			rotation+=((menuitem-numchoices)-rotation)/numchoices;
		}else{
			rotation+=((menuitem)-rotation)/numchoices;
		}
		while(rotation>numchoices){rotation-=numchoices;}
		while(rotation<0){rotation+=numchoices;}
		yield;
	}
	yield;
	yield;
	ClearText(2);
	ClearText(3);
	stage=choicelist[menuitem%uniquechoices]+1;

task ExtraStageRainbow(obj,len,type){
	let k=0;
	let j=0;

	let fixcolor=[[1,0,1],[-0.2,1,-0.2],[0,0.5,1]][type];

	let frame=rand(0,360);
	let color=[0,0,0];
	while(!Obj_BeDeleted(obj)){
		k=0;
		loop(len){
			j=0;
			color=RainbowArray(k*(360/len)+frame*4,105,100);
			loop(6){
				ObjEffect_SetVertexColor(obj,k*6+j,255,
					lower(color[0]+fixcolor[0]*120,255),
					lower(color[1]+fixcolor[1]*120,255),
					lower(color[2]+fixcolor[2]*120,255));
				j++;
			}
			k++;
		}
		frame++;
		yield;
	}

}

}

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

//33-35

let mainc1=[250,250, 70, 70, 70,250,250,250];
let mainc2=[70, 250,250,250, 70,150,250, 70];
let mainc3=[250, 70, 70,250,250, 70,250, 70];

let menutext=["Game Start","How to Play","Single Stage","Boss Practice","Results","Music Room","Options","Quit","Extra Start"];
let menudesc=["Start the game from the beginning.","I know this option is useless in most games, but this one's fun!","Play any stage you've seen or unlocked.","Fight any boss pattern you've seen, and try to clear them all. ","View your scores and records.","Listen to any song in the game.","Change various game options.","Noooo, don't leave!","When the normal stages aren't enough..."];

let mainmenuselection=0;

function MainMenu{
	let numchoices=8;
	let choicearray=[0,1,2,3,4,5,6,7];
	if(!IsAWCPlayer){
		numchoices=7;
		choicearray=[0,2,3,4,5,6,7];
	}

	CreateMenu(numchoices,0,1);

	InMenu=3;
	let ddu=0;
	let ctext=0;
	SetFontStyle(1,3,0,0,1,10);
	SetFontColorNew(100,100,100,170,170,170);
	let obj=[];
	let objlen=[];
	menuitem=mainmenuselection;
	let rotation=menuitem;
	loop(numchoices){
		obj=obj~[DrawTextNewObj(4,menutext[choicearray[ddu]],imgText,390,sin(WheelPos(ddu,rotation,numchoices))*100+300,0,5,5,8,1,205,1)];
		objlen=objlen~[length(menutext[choicearray[ddu]])];
		ddu++;
	}
	ddu=0;
	let inmenusave=0;
	ctext=-1;
	let selectobj;
	let endloop=false;
	while(InMenu==3&&!endloop){
		if(ctext!=menuitem){
			ClearTextImmediately(5);
			yield;
			yield;
			yield;
			ClearTextImmediately(5);
			ctext=menuitem;
			SetFontColorNew(255,255,255,mainc1[choicearray[ctext]],mainc2[choicearray[ctext]],mainc3[choicearray[ctext]]);
			SetFontStyle(0,0,0,0,0,0);
			selectobj=DrawTextNewObj(5,menutext[choicearray[ctext]],imgText,390,sin(WheelPos(menuitem,rotation,numchoices))*100+300,0,5,5,8,1,255,0);
			DrawDescription(menudesc[choicearray[ctext]]);
			menumove=1;
		}


		ddu=0;
		loop(numchoices){
			Obj_SetPosition(obj[ddu],390,sin(WheelPos(ddu,rotation,numchoices))*100+300 );
			Obj_SetColor(obj[ddu],objlen[ddu]*6,upper(0,cos(WheelPos(ddu,rotation,numchoices))*200),255,255,255);
			ddu++;
		}

		Obj_SetPosition(selectobj,390,sin(WheelPos(menuitem,rotation,numchoices))*100+300 );

		Sparkle(390+rand(0,objlen[menuitem]*16),sin(WheelPos(menuitem,rotation,numchoices))*100+300+rand(-12,12),  0.2,rand(0,360),0.5,60,80);

		if(absolute((menuitem+numchoices)-rotation)<absolute(menuitem-rotation)){
			rotation+=((menuitem+numchoices)-rotation)/numchoices;
		}else if(absolute((menuitem-numchoices)-rotation)<absolute(menuitem-rotation)){
			rotation+=((menuitem-numchoices)-rotation)/numchoices;
		}else{
			rotation+=((menuitem)-rotation)/numchoices;
		}
		while(rotation>numchoices){rotation-=numchoices;}
		while(rotation<0){rotation+=numchoices;}

		if(GetKeyState(VK_BOMB)==KEY_PUSH){
			SE("cancel");
			if(menuitem!=numchoices-1){
				menuitem=numchoices-1;
			}else {endloop=true;}
		}

		yield;
	}
	mainmenuselection=menuitem;
	menuitem=choicearray[menuitem];
	if(menuitem==0&&GetCommonDataDefault("FirstTimePlaying",true)&&IsAWCPlayer){
		ConfirmStart;
		SetCommonData("FirstTimePlaying",false);
	}
	yield;
	yield;
	ClearText(4);
	ClearText(5);
	ClearTextImmediately(127);
}
function WheelPos(ddu,rotation,maxnum){
	ddu=(ddu-rotation)*(180/maxnum);
	ddu+=90;
	while(ddu<0){ddu+=180;}
	while(ddu>180){ddu-=180;}
	ddu-=90;
	return ddu;
}
//---------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------

//36-39

#include_function GetCurrentScriptDirectory~"..\..\spelldefs.txt"

let spellc1= [0,1,1,1,0];
let spellc2= [1,1,0,0,1];
let spellc3= [0,0,0,1,1];

task SpellPractice{
	
	InMenu=4;
	yield;
	let difffade=0;
	let dopacity=5;
	let ddu=0;
	let cchoice=0;
	let cwidth=0;
	let ctext=-1;
	let page=0;
	let textcleared=0;
	let curnum=0;
	let diffsp=0;
	let curpage=0;
	let scroll=rand_int(0,2000);
	let spelldescstr=[""];
	SetFontStyle(1,3,0,0,1,10);
	SetFontColorNew(200,200,200,200,200,200);
	let DiffIcon="  ";
	menuitem=GetCommonDataDefault("SpellPracticeSelection",menuitem);
	curnum=menuitem;
	DeleteCommonData("SpellPracticeSelection");
	SaveCommonData;
	curpage=trunc(menuitem/perpage);
	DrawSpells(curpage);
	let selectory=25*(curnum%perpage)+25;
	SetFontStyle(1,0,0,0,0,5);
	let LastTime=GetTime;
	let inmenusave=0;
	if(GetCommonDataDefault("PracticeAutoReset",-1)==-1){
		SetCommonData("PracticeAutoReset",1);
	}
	let firstframe=true;
	while(dopacity>0){
		scroll+=(LastTime-GetTime)/30;
		LastTime=GetTime;

		selectory+=((25*(curnum%perpage)+22)-selectory)/3;
		DrawObject(objects[36],stgwhite,0,0,640,480,320,240,1,1,ALPHA,dopacity*0.4,8,0,0,0,0,0,0);
		DrawObject(objects[37],imgSelector,0-scroll,0,320-scroll,32,320,selectory,2,1.4,ADD,dopacity*0.7,8,255,255,255,0,0,0);
		DrawObject(objects[38],imgSelector,0-scroll*2.5,0,320-scroll*2.5,32,320,selectory,2,-1.4,ADD,dopacity*0.7,8,255,255,255,0,0,0);
		DrawObject(objects[39],stgwhite,0,0,640,60,320,408,1,1,ALPHA,dopacity*0.8,8, Rainbow(0,scroll*2)*30,Rainbow(1,scroll*2)*30,Rainbow(2,scroll*2)*30, 0,0,0);

		if(GetKeyState(VK_RIGHT)==KEY_PUSH&&curpage<trunc(numspells/perpage)&&InMenu==4){menuitem+=perpage;SE("select");menuselectable=0;}
		if(GetKeyState(VK_LEFT)==KEY_PUSH&&curpage>0&&InMenu==4) {menuitem-=perpage;SE("select");menuselectable=0;}
		if(GetKeyState(VK_SLOWMOVE)==KEY_PUSH&&InMenu==4||firstframe){
			if(!firstframe){
				SetCommonData("PracticeAutoReset",1-GetCommonDataDefault("PracticeAutoReset",0));
				SE("select");
			}
			SetFontColorNew(255,255,255,255,100,255);
			SetFontColorEmphasis(255,255,255,255,255,255);
			ClearTextImmediately(8);
			spelldescstr=["OFF","ON"][GetCommonDataDefault("PracticeAutoReset",0)];
			DrawTextBoldObj(8,"Up/down scrolls, left/right switches pages.",imgText,320,435,0,3,3,8,0,255,0);
			DrawTextBoldObj(8,"Reset on death is currently #"~spelldescstr~"#, toggle with focus key (shift)",imgText,320,452,0,3,3,8,0,255,0);
		}
		firstframe=false;

		if(ctext!=menuitem&&InMenu==4){
			ClearTextImmediately(7);
			if(menuitem>=perpage*(curpage+1)||menuitem<perpage*curpage){
				if(menuitem>=numspells&&menuitem<perpage*curpage){
					menuitem=numspells-1;
				}
				curpage=trunc(menuitem/perpage);
				DrawSpells(curpage);
			}
			Wait(2);

			ctext=menuitem;
			diffsp=spelln[ctext*6+3];

			curnum=ctext;

			DiffIcon=difficultyicons[diffsp];
			SetFontColorSpell(curnum,255);
			if(GetCommonDataDefault("PracticeA"~IntString(spelln[curnum*6]),0)>0||UnlockReq(curnum)){
				menuselectable=1;
				DrawTextNew(7,
					NumPadE(IntString(spelln[curnum*6]+1),3)~spell[curnum*4]~DiffIcon~spell[curnum*4+1]
					~LPad(IntString(GetCommonDataDefault("PracticeC"~IntString(spelln[curnum*6]),0)),3)~"/"
					~Pad(IntString(GetCommonDataDefault("PracticeA"~IntString(spelln[curnum*6]),0)),3)
					,imgText,14,25*(curnum%perpage)+6,0,3,3,8,1,255,0);
			}else{
				menuselectable=0;
//				menuselectable=1;
				DrawTextNew(7,
					NumPadE(IntString(spelln[curnum*6]+1),3)~spell[curnum*4]~DiffIcon~"??????                                      0/0"
					,imgText,14,25*(curnum%perpage)+6,0,3,3,8,1,255,0);
			}
			if(GetCommonDataDefault("PracticeC"~IntString(spelln[curnum*6]),0)==0){
				if(GetCommonDataDefault("PracticeA"~IntString(spelln[curnum*6]),0)>0){
					spelldescstr=WrapText("You haven't cleared this attack yet!",52);
					SetFontColorNew(200,200,200,200,64,64);
				}else{
					spelldescstr=WrapText("You haven't seen this attack yet!",52);
					SetFontColorNew(200,200,200,100,100,100);
				}
			}else{
				spelldescstr=WrapText(spell[curnum*4+3],52);
				SetFontColorNew(255,255,255,64,196,255);
			}
			diffsp=391-(length(spelldescstr)-1)*19*0.5;//used as y position
			loop(length(spelldescstr)){
				DrawTextBoldObj(7,spelldescstr[0],imgText,40,diffsp,0,3.5,3.5,8,1,255,0.2);
				diffsp+=19;
				spelldescstr=erase(spelldescstr,0);
			}
			menumove=1;
		}

		ddu+=0.5;
		if(InMenu!=4){
			inmenusave=1;
		}
		if(inmenusave==1){
			dopacity-=5;
			if(textcleared==0){
				SpellPracticeFade;
				textcleared=1;
			}
		}
		else if(dopacity<250){dopacity+=10;}
		if(InMenu==4){
			Sparkle(rand(0,700),selectory+rand(-10,10)-3,rand(1,1.5),rand(170,190),0.5,60,130);
		}
		yield;
	}
}
let fontcolorspell1=[0.9,0.5];
let fontcolorspell2=[0.3,0.8];
let fontcolorspell3=[0  ,1];
function SetFontColorSpell(num,max){
	let capped=0;
	if(GetCommonDataDefault("PracticeA"~IntString(spelln[num*6]),0)>0||UnlockReq(num)){
		if(GetCommonDataDefault("PracticeC"~IntString(spelln[num*6]),0)>0){capped=1;}
		SetFontColorNew(max,max,max,fontcolorspell1[capped]*max,fontcolorspell2[capped]*max,fontcolorspell3[capped]*max);
	}else{
		SetFontColorNew(200,200,200,100,100,100);
	}
}
function UnlockReq(curnum){
	let ret=false;
	if(spelln[curnum*6]>=500){
		ret=false;
	}

	return ret;
}
let difficultyicons=["{ ","} ","| ","` "];
let drawingspells=0;
task DrawSpells(page){
	drawingspells=1;
	yield;
	drawingspells=0;
	page*=perpage;
	let curpage=trunc(menuitem/perpage);
	let curnum=menuitem;
	let curnum2=menuitem;
	SetFontColorNew(255,255,255,155,155,155);
	ClearTextImmediately(6);
	DrawTextBoldObj(6,"- Page "~IntString(page/perpage+1)~" / "~IntString(trunc(numspells/perpage)+1)~" -",imgText,320,350,0,3,3,8,0,255,0);
	let k=0;
	while(k<perpage&&drawingspells==0&&InMenu==4){
		if(curnum-curpage*perpage>=0){
			DrawSpell(curnum,curpage);
		}
		if(curnum2!=curnum&&curnum2-curpage*perpage<perpage){
			DrawSpell(curnum2,curpage);
		}
		curnum2++;
		curnum--;
		yield;
	}
}
function DrawSpell(curnum,curpage){
	let spellposition=(curnum%perpage);
	ClearTextImmediately(spellposition+500);
	if(curnum<numspells&&trunc(menuitem/perpage)==curpage){

		let diffsp=spelln[curnum*6+3];
		let col=[spellc1[diffsp],spellc2[diffsp],spellc3[diffsp]];

		let DiffIcon=difficultyicons[diffsp];
		SetFontColorSpell(curnum,150);
		if(GetCommonDataDefault("PracticeA"~IntString(spelln[curnum*6]),0)>0||UnlockReq(curnum)){
			DrawTextNew(spellposition+500,
				NumPadE(IntString(spelln[curnum*6]+1),3)~spell[curnum*4]~DiffIcon~spell[curnum*4+1]
				~LPad(IntString(GetCommonDataDefault("PracticeC"~IntString(spelln[curnum*6]),0)),3)~"/"
				~Pad(IntString(GetCommonDataDefault("PracticeA"~IntString(spelln[curnum*6]),0)),3)
				,imgText,15,25*spellposition+7,0,3,3,8,1,255,0);
		}else{
			DrawTextNew(spellposition+500,
				NumPadE(IntString(spelln[curnum*6]+1),3)~spell[curnum*4]~DiffIcon~"??????                                      0/0"
				,imgText,15,25*spellposition+7,0,3,3,8,1,255,0);
		}
	}
}
task SpellPracticeFade{
	ClearTextImmediately(6);
	ClearTextImmediately(7);
	ClearTextImmediately(8);
	let k=0;
	loop(perpage){
		ClearTextImmediately(500+k);
		k++;
	}
}

task SpellSpawn(ID){
	yield;
	SetCommonData("Stagenum2",1);
	SetCommonData("Diff",spelln[ID*6+3]);
	SetCommonData("BGInit",0);
	if(GetCommonDataDefault("Spellnum",-1)==-1){
		FadeWhite(0,255,30);
		Wait(33);
		SetCommonData("Spellnum",ID);
		if(IsReplay==false){SaveCommonData;}
		Retry;
		yield;
	}else{
		CreateBoss(GetCenterX,-40,spelln[ID*6+4],spell[ID*4+2],[""],[[1]],0,1,spelln[ID*6+5]);
		if(IsReplay==false){DeleteCommonData("Spellnum");SaveCommonData;}

		let cont=0;
	
		AddScore(-GetScore);
		AddPoint(-GetPoint);
		AddGraze(-GetGraze);
		Wait(30);
	
		AddScore(-GetScore);
		AddPoint(-GetPoint);
		AddGraze(-GetGraze);
		if(GetCommonDataDefault("PracticeAutoReset",0)==0){
			ForbidShot2(false);
		}
		SpawnBoss;
		let skipped=WaitForBossDeadPractice(ID);
		ForbidShot2(true);

		let longexplosion=false;
		if(!skipped){
			if(!OnPlayerMissed&&GetMissCount==0&&GetCommonDataDefault("PracticeAutoReset",1)==1){longexplosion=true;}
			if(GetCommonDataDefault("PracticeAutoReset",1)==0){longexplosion=true;}
			if(longexplosion){
				Wait(250);
			}else{
				Wait(60);
			}
		}else{
			SetCommonData("Spellnum",ID);
			SaveCommonData;
			ClearedGame=2;
			Wait(20);
			if(GetKeyState(VK_SKIP)==KEY_HOLD){
				DeleteCommonData("Spellnum");
				SetCommonData("Spellexitnum",ID);
				SaveCommonData;			
			}
			loop{yield;}
		}
		DeleteCommonData("SpellPractice");
		if(IsReplay==false){SaveCommonData;}
		cont=ContinueYN;
		FreezeTime(true);
		if(cont==0){
			SpellSpawn(ID);
		}else if(cont==2){
			SetCommonData("Spellexitnum",ID);
			SaveCommonData;
			ClearedGame=2;
		}else{
			ClearedGame=1;
		}
	}
}

//function IncrementCapture(ID){
//	if(IsReplay==false&&GetCommonDataDefault("PracticeC"~IntString(ID),0)<999){SetCommonData("PracticeC"~IntString(ID),GetCommonDataDefault("PracticeC"~IntString(ID),0)+1);SaveCommonData;}
//}

function ContinueYN{
	if(IsReplay==true){Clear;}
	FreezeTime(true);
	SetFontStyle(1,3,0,0,1,10);
	let selected=0;
	let selectedmenu=0;
	let obj=Obj_Create(OBJ_EFFECT);
	DrawObject(obj,stgwhite,0,0,GetClipMaxX-GetClipMinX,GetClipMaxY-GetClipMinY,GetCenterX,GetCenterY,1,1,ALPHA,255*0.4,8,0,0,0,0,0,0);
	SetFontColorNew(255,255,255,255,200,200);
	DrawTextNew(9,"Try again?",imgText,GetCenterX,180,0,4,4,8,0,255,0);
	SetFontColorNew(255,255,255,200,200,200);
	DrawTextNew(7,"Yes",imgText,GetCenterX,230,0,4,4,8,0,180,0);
	DrawTextNew(7,"No",imgText,GetCenterX,260,0,4,4,8,0,180,0);

	SetFontColorNew(255,255,255,196,220,255);
	DrawTextNew(8,"Yes",imgText,GetCenterX,230,0,4,4,8,0,255,0);
	let frame=0;
	let ycenter=[230,260];
	let width=[3,2];
	while(selected==0){
		if(GetKeyState(VK_UP)==KEY_PUSH||GetKeyState(VK_DOWN)==KEY_PUSH){
			SE("select");
			yield;
			ClearTextImmediately(8);
			yield;
			selectedmenu=1-selectedmenu;
			if(selectedmenu==0){
				DrawTextNew(8,"Yes",imgText,GetCenterX,230,0,4,4,8,0,255,0);
			}else{
				DrawTextNew(8,"No",imgText,GetCenterX,260,0,4,4,8,0,255,0);
			}
		}

		if(GetKeyState(VK_SHOT)==KEY_PUSH){selected=1;SE("ok");}//continue
		Sparkle(GetCenterX+cos(frame)*30,    ycenter[selectedmenu]+16+sin(frame)*12,    cos(frame),0,0.3,30,255);
		frame+=187;
		yield;
	}

	ClearTextImmediately(9);
	ClearTextImmediately(8);

	if(selectedmenu==1){
		SetFontColorNew(255,255,255,255,200,200);
		DrawTextNew(9,"Save replay?",imgText,GetCenterX,180,0,4,4,8,0,255,0);	
		DrawTextBoldObj(9,"You need to choose      next screen if you pick yes.",imgText,GetCenterX,197,0,2.2,2.8,8,0,255,0);
		DrawTextBoldObj(9,"Blame that on Danmakufu, not me.",imgText,GetCenterX,209,0,2.2,2.8,8,0,255,0);
		DrawTextNewKana(9,"ha i",imgText,GetCenterX-19,197,0,5,3.5,8,0,255,0);
		selected=0;
		selectedmenu=2;
		SetFontColorNew(255,255,255,196,220,255);
		DrawTextNew(8,"No",imgText,GetCenterX,260,0,4,4,8,0,255,0);
		while(selected==0){
			if(GetKeyState(VK_UP)==KEY_PUSH||GetKeyState(VK_DOWN)==KEY_PUSH){
				SE("select");
				yield;
				ClearTextImmediately(8);
				yield;
				selectedmenu=(1-(selectedmenu-1))+1;
				if(selectedmenu==1){
					DrawTextNew(8,"Yes",imgText,GetCenterX,230,0,4,4,8,0,255,0);
				}else{
					DrawTextNew(8,"No",imgText,GetCenterX,260,0,4,4,8,0,255,0);
				}
			}
			Sparkle(GetCenterX+cos(frame)*30,    ycenter[selectedmenu-1]+16+sin(frame)*12,    cos(frame),0,0.3,30,255);
			frame+=187;
	
			if(GetKeyState(VK_SHOT)==KEY_PUSH){selected=1;SE("ok");}//continue
			yield;
		}
	}

	yield;
	ClearTextImmediately(8);
	ClearTextImmediately(7);
	Obj_Delete(obj);
	FreezeTime(false);
	return selectedmenu;
}

function Pad(str,num){
	loop(num-length(str)){
		str=str~[' '];
	}
	return str;	
}
function LPad(str,num){
	loop(num-length(str)){
		str=[' ']~str;
	}
	return str;	
}
function NumPad(str,num){
	loop(num-length(str)){
		str=['0']~str;
	}
	str=str~[' '];
	return str;	
}
function NumPadE(str,num){
	let str=NumPad(str,num);
	if(str[0]=='5'){str[0]='X';}
	return str;
}
//---------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------------------------------------------------------------------

let optiontext=["Starting Lives","Practice reset","Hitbox Type","Dialogue","Effects","Backgrounds","Player Shots","Back"];
let optionselections=[["1","2","3","4","5","Unlimited"],["On","Off","Double-tap"],["Burst","Dot","Off"],["On","Off"],["High","Med","Low"],["On","Off","Yay"],[""]]; let optionnum=[6,3,3,2,3,3,0,0];
let optionxoffset=[[0,20,40,60,80,115],[0,50,110],[0,75,125],[0,50],[0,60,105],[0,50,105],[0,50]];
let optioncurrent=[0,0,0,0,0,0,0,0];
let optiondescriptor1=["Set the number of lives to begin the game with (default is 3).","If on, you can tap the message skip key (usually \ctrl\) to","Changes the type of hitbox shown while","Turns in-game dialogue and cutscenes on or off.","Changes the amount of detail for effects. Lower this if","Turns backgrounds on or off. Keep this on unless you're","Set the visibility of player shots. Lower makes them"];
let optiondescriptor2=["More games need to have an \unlimited\ option, you know?","quick-reset in practice mode, or hold it to return to the menu.","focusing, or turns it off entirely.","Even if it is on, you can still manually skip them.","there is slowdown during certain parts of the game.","experiencing lots of slowdown, or if the shininess distracts you.","more transparent if you're having trouble seeing past them."];

task Options{
	CreateMenu(7,1,1);

	InMenu=5;
	OptionsBorder;
	yield;
	optioncurrent=GetCommonDataDefault("OptionsMenu",[2,0,0,0,0,0,0.5]);
	let difffade=0;
	let dopacity=250;
	let ddu=0;
	let cchoice=0;
	let cwidth=0;
	let ctext=-1;
	let k=0;
	let k2=0;
	SetFontStyle(1,3,0,0,1,10);

//	SetFontColorNew(255,255,255,170,190,210);
	SetFontStyle(0,0,0,0,0,0);

	DrawSliderThing;

	SetFontColorNew(100,100,100,170,170,170);

	k=0;
	loop(7){
		DrawTextNew(10,optiontext[k],imgText,380,20+55*k,0,5,5,8,1,205,1); loop(2){yield;}
		k++;
	}
	k=0;
	loop(6){
		k2=0;
		SetFontColorNew(100,100,100,170,170,170);
		while(k2<optionnum[k]){
			if(k!=5||k2!=2){
				DrawTextNew(10,optionselections[k][k2],imgText,399+optionxoffset[k][k2],44+55*k,0,3.5,3.5,8,1,255,2);
			}
			k2++;
		}
		SetFontColorNew(255,255,255,128,128,255);
		DrawTextBoldObj(12+k,optionselections[k][optioncurrent[k]],imgText,399+optionxoffset[k][optioncurrent[k]],44+55*k,0,3.5,3.5,8,1,255,2);
		if(k==0&&optioncurrent[0]==5){
			DrawWarning;
		}
		k++;
	}

	DrawOptionDescription(optiondescriptor1[0],0);
	DrawOptionDescription(optiondescriptor2[0],1);

	SetFontStyle(1,0,0,0,0,5);
	let frame=0;
	while(dopacity==250){
		if(ctext!=menuitem){
			yield;
			ClearText(11);
			ctext=menuitem;
			SetFontColorNew(255,255,255,255,128,255);
			SetFontStyle(1,0,0,0,0,5);
			DrawTextNew(11,optiontext[ctext],imgText,379,19+55*ctext,0,5,5,8,1,255,1);
			SubMenu(menuitem,optionnum[menuitem]);
			DrawOptionDescription(optiondescriptor1[ctext],0);
			DrawOptionDescription(optiondescriptor2[ctext],1);
			menumove=1;
		}

		if(frame>10/length(optiontext[ctext])){
			Sparkle(379+rand(0,length(optiontext[ctext]))*16,rand(22,45)+55*ctext,0.2,rand(0,360),0.5,60,80);
			frame-=10/length(optiontext[ctext]);
		}
		frame++;

		ddu+=0.5;
		if(InMenu!=5){OptionsMenuFade;dopacity-=2;}
		yield;
	}

task DrawSliderThing{
	let obj1=InitEffect(400,382,stgwhite,4,ALPHA,8);
	ObjEffect_SetXYRect(obj1,0,0,150,12);
	ObjEffect_SetUVRect(obj1,0,0,10,10);
	let obj2=InitEffect(400,382,stgwhite,4,ALPHA,8);
	ObjEffect_SetXYRect(obj2,-1,0,1,12);
	ObjEffect_SetUVRect(obj2,0,0,10,10);

	SetFontColorNew(255,255,255,255,255,255);
	SetKerning(8);
	let text1=DrawTextNewObj(10,"clear",imgText,400,388,0,2.5,3,8,1,0,0);
	let text2=DrawTextNewObj(10,"solid",imgText,550,388,0,2.5,3,8,-1,0,0);

	Obj_SetX(obj2,400+optioncurrent[6]*150);

	let speed=20;
	let frame=0;
	let totalframe=0;
	let alpha=0;
	while(InMenu==5){
		if(alpha<1){
			alpha+=1/20;
			Obj_SetColor(text1,6*5,(255-optioncurrent[6]*150)*alpha,255,255,255);
			Obj_SetColor(text2,6*5,(optioncurrent[6]*150+105)*alpha,255,255,255);
			Obj_SetColor(obj1,4,150*alpha,0,0,0);
		}
		if(menuitem==6){
			if(GetKeyState(VK_RIGHT)==KEY_PUSH||GetKeyState(VK_LEFT)==KEY_PUSH){
				speed=15;
				frame=1;
			}
			if(GetKeyState(VK_LEFT)!=KEY_FREE&&frame<=0){
				optioncurrent[6]=optioncurrent[6]-0.1;
				frame=speed;
				speed=lower(speed-1,10);
				Obj_SetColor(text1,6*5,255-optioncurrent[6]*150,255,255,255);
				Obj_SetColor(text2,6*5,optioncurrent[6]*150+105,255,255,255);
			}
			if(GetKeyState(VK_RIGHT)!=KEY_FREE&&frame<=0){
				optioncurrent[6]=optioncurrent[6]+0.1;
				frame=speed;
				speed=lower(speed-1,10);
				Obj_SetColor(text1,6*5,255-optioncurrent[6]*150,255,255,255);
				Obj_SetColor(text2,6*5,optioncurrent[6]*150+105,255,255,255);
			}
			frame--;
			optioncurrent[6]=center(0,optioncurrent[6],1);
			Obj_SetX(obj2,400+optioncurrent[6]*150);
			totalframe++;
		}else{
			totalframe=0;
		}
		Obj_SetColor(obj2,4,(cos(totalframe*20)*-50+205)*alpha,255,255,255);
		yield;
	}
	Obj_Delete(obj1);
	Obj_Delete(obj2);
}
}
task SubMenu(val,num){
	if(num>0){
		while(menuitem==val){
			if(GetKeyState(VK_RIGHT)==KEY_PUSH&&optioncurrent[val]<num-1){
				yield;
				ClearText(12+val);
				yield;
				ClearText(12+val);
				optioncurrent[val]=(optioncurrent[val]+1+num)%num;
				SetFontStyle(1,0,0,0,0,5);
				SetFontColorNew(255,255,255,128,128,255);
				DrawTextBoldObj(12+val,optionselections[val][optioncurrent[val]],imgText,399+optionxoffset[val][optioncurrent[val]],44+55*val,0,3.5,3.5,8,1,255,2);
				if(val==0&&optioncurrent[0]==5){
					DrawWarning;
				}
				SE("select");
			}
			if(GetKeyState(VK_LEFT)==KEY_PUSH&&optioncurrent[val]>0){
				yield;
				ClearText(12+val);
				yield;
				ClearText(12+val);
				optioncurrent[val]=(optioncurrent[val]-1+num)%num;
				SetFontStyle(1,0,0,0,0,5);
				SetFontColorNew(255,255,255,128,128,255);
				DrawTextBoldObj(12+val,optionselections[val][optioncurrent[val]],imgText,399+optionxoffset[val][optioncurrent[val]],44+55*val,0,3.5,3.5,8,1,255,2);
				if(val==0&&optioncurrent[0]==5){
					DrawWarning;
				}
				SE("select");
			}
			yield;
		}
	}
}
function DrawWarning{
	SetFontColorNew(255,255,255,255,0,0);
	DrawTextBoldObj(12,"High scores will not be saved!",imgText,380,57,0,2.5,3,8,1,255,0.5);
}
task OptionsMenuFade{
	yield;
	SetCommonData("OptionsMenu",optioncurrent);
	if(IsReplay==false){SaveCommonData;}
	loop(3){
		ClearText(10);
		ClearTextImmediately(11);
		ClearTextImmediately(12);
		ClearTextImmediately(13);
		ClearTextImmediately(14);
		ClearTextImmediately(15);
		ClearTextImmediately(16);
		ClearTextImmediately(17);
		ClearTextImmediately(18);
		ClearTextImmediately(19);
		Wait(5);
	}
}

task DrawDescription(string){
	yield;
	ClearTextImmediately(127);
	yield;
	SetFontStyle(0,0,0,0,0,0);
	SetFontColorNew(0,0,0,0,0,0);
	DrawTextNew(127,string,imgText,323,453,0,3,3.3,8,0,180,0);	
	yield;
	SetFontColorNew(255,255,255,255,100,255);
	DrawTextBoldObj(127,string,imgText,320,450,0,3,3.3,8,0,255,0);	
}
task DrawOptionDescription(string,y){
	yield;
	ClearTextImmediately(19);
	yield;
	SetFontStyle(0,0,0,0,0,0);
	SetFontColorNew(0,0,0,0,0,0);
	DrawTextNew(19,string,imgText,323,435+y*18,0,3,3.3,8,0,180,0.1);
	yield;
	SetFontColorNew(255,255,255,255,100,255);
	DrawTextBoldObj(19,string,imgText,320,432+y*18,0,3,3.3,8,0,255,0.1);
}
task OptionsBorder{
	let obj1=InitEffect(0,0,stgwhite,4,SUBTRACT,8);
	let obj2=InitEffect(0,0,stgwhite,4,SUBTRACT,8);
	ObjEffect_SetXYRect(obj1,300,0,640,480);
	ObjEffect_SetUVRect(obj1,300,0,640,480);
	ObjEffect_SetXYRect(obj2,220,0,300,480);
	ObjEffect_SetUVRect(obj2,220,0,300,480);

	let k=0;
	let alpha=0;
	while(InMenu==5){
		alpha+=8;
		alpha=center(0,alpha,200);
		Obj_SetColor(obj1,4,alpha/2,255,255,255);
		ObjEffect_SetVertexColor(obj2,0,0,255,255,255);
		ObjEffect_SetVertexColor(obj2,1,alpha/2,255,255,255);
		ObjEffect_SetVertexColor(obj2,2,alpha/2,255,255,255);
		ObjEffect_SetVertexColor(obj2,3,0,255,255,255);

		yield;
	}
	while(alpha>0){
		alpha-=8;
		alpha=center(0,alpha,200);
		Obj_SetColor(obj1,4,alpha/2,255,255,255);
		ObjEffect_SetVertexColor(obj2,0,0,255,255,255);
		ObjEffect_SetVertexColor(obj2,1,alpha/2,255,255,255);
		ObjEffect_SetVertexColor(obj2,2,alpha/2,255,255,255);
		ObjEffect_SetVertexColor(obj2,3,0,255,255,255);

		yield;
	}
	Obj_Delete(obj1);
	Obj_Delete(obj2);
}

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

function ConfirmStart{
	yield;
	let obj=InitEffect(320,240,stgwhite,4,ALPHA,8);
	ObjEffect_SetXYRect(obj,-200,-100,200,60);
	ObjEffect_SetUVRect(obj,0,0,2,2);
	menuitem=0;
	let frame=0;
	SetFontStyle(0,0,0,0,0,0);
	SetFontColorNew(255,255,255,255,100,100);
	DrawTextNew(1002,"Small note!",imgText,320,240-100,0,4,4,8,0,255,1);
	SetFontColorNew(255,255,255,255,100,255);
	DrawTextBoldObj(1002,"I know you're eager to start playing,",imgText,320,240-85,0,3,3,8,0,255,0.5);
	DrawTextBoldObj(1002,"but there's an awesome tutorial mode",imgText,320,240-70,0,3,3,8,0,255,0.5);
	DrawTextBoldObj(1002,"that will teach you some stuff. It's",imgText,320,240-55,0,3,3,8,0,255,0.5);
	DrawTextBoldObj(1002,"optional, of course, but try it out!",imgText,320,240-40,0,3,3,8,0,255,0.5);
	SetFontColorNew(255,255,255,100,100,100);
	DrawTextBoldObj(1002,"Show me how to play first!",imgText,320,240-10,0,3.5,3.5,8,0,185,0.5);
	DrawTextBoldObj(1002,"(also comes with free cookies)",imgText,320,240+3,0,2.5,2.5,8,0,185,0.5);
	DrawTextBoldObj(1002,"No thanks, I'll just figure it out",imgText,320,240+25,0,3.5,3.5,8,0,185,0.5);
	let selection=-1;
	let obj2=[-1,-1];
	let k=0;
	while(GetKeyState(VK_SHOT)!=KEY_PUSH){
		Obj_SetColor(obj,4,lower(frame*5,200),0,0,0);
		if(frame%2==0){
			Sparkle(320+200,240+rand(-100,60),rand(-1,1),90,1,60,255);
			Sparkle(320+rand(-200,200),240+60,rand(-1,1),0,1,60,255);
		}else if(frame%2==1){
			Sparkle(320-200,240+rand(-100,60),rand(-1,1),90,1,60,255);
			Sparkle(320+rand(-200,200),240-100,rand(-1,1),0,1,60,255);
		}
		if(GetKeyState(VK_DOWN)==KEY_PUSH&&selection==0){
			SE("select");
			menuitem=1;
		}
		if(GetKeyState(VK_UP)==KEY_PUSH&&selection==1){
			SE("select");
			menuitem=0;
		}
		if(selection!=menuitem){
			SetFontColorNew(100,255,255,100,200,255);
			ClearText(1003);
			if(menuitem==0){
				obj2[0]=DrawTextBoldObj(1003,"Show me how to play first!",imgText,320,240-10,0,3.5,3.5,8,0,255,0.5);
				obj2[1]=DrawTextBoldObj(1003,"(also comes with free cookies)",imgText,320,240+3,0,2.5,2.5,8,0,255,0.5);
			}else{
				obj2[0]=DrawTextBoldObj(1003,"No thanks, I'll just figure it out",imgText,320,240+25,0,3.5,3.5,8,0,255,0.5);
				obj2[1]=-1;
			}
			selection=menuitem;
		}
		Obj_SetColor(obj2[0],[21,28][selection]*6,200+sin(frame*14)*55,100,200,255);
		if(selection==0){
			Obj_SetColor(obj2[1],26*6,200+sin(frame*14)*55,100,200,255);
		}

		frame++;
		yield;
	}
	SE("ok");
	ClearTextImmediately(1002);
	ClearText(1003);
	menuitem=1-menuitem;
	let alpha=lower(frame*5,200);
	let alphaadd=alpha/10;
	loop(10){
		alpha-=alphaadd;
		Obj_SetColor(obj,4,alpha,0,0,0);
		yield;
	}
	Obj_Delete(obj);
}


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

function ResultsScreen{

	let x=[1,0,1];
	let y=[0,1,1];

	let k=0;
	loop(4){
		LoadGraphic(GPSD~"img\stage"~IntString(k)~".png");
		yield;
		k++;
	}
	k=1;
	loop(4){
		LoadGraphic(GPSD~"img\diff"~IntString(k)~".png");
		yield;
		k++;
	}


	DrawOptionDescription("Up/down changes between full game and individual stage scores.",0);
	DrawOptionDescription("Left/right changes between characters.",1);

	let maxtime=1;
	k=1;
	loop(5){
		if(playtime[k]>0){
			maxtime=k;
		}
		k++;
	}

	let str="";
	k=1;
	loop(5){
		if(maxtime>=k){
			if(k>1){
				str=", "~str;
			}
			str=IntString(playtime[k])~[playstr[k]]~str;
			k++;
		}
	}

	SetFontStyle(0,0,0,0,0,0);
	SetFontColorNew(255,255,255,180,180,255);
	DrawTextBoldObj(19,"Play Time: "~str,imgText,160,20,0,3,3,8,0,255,1);

	let maxpages=1;
	loop(3){
		if(IsSeenStageAll(maxpages)){maxpages++;}
	}
	maxpages=5;

	let pagetype=[1,1,1,1,0];

	let page=0;
	let curpage=-1;
	let char=0;
	let curchar=-1;

	let loops=0;
	let delay=0;
	let stilllooping=true;
	let redrawstage=false;
	let vdir=1;
	let hdir=1;
	DrawChar(page);
	DrawStageName(page);
	yield;

	let nebular=[255,170,170];
	let nebulag=[170,255,235];
	let nebulab=[255,170,255];
	k=0;
	loop(3){
		yield;
		DrawDiffThingBG(k,k+1,1, 255,255,255);
		DrawDiffThingBG(k,4,0,   nebular[k],nebulag[k],nebulab[k]);
		k++;
	}
	k=0;
	let dopacity=0;
	while(((GetKeyState(VK_SHOT)!=KEY_PUSH&&GetKeyState(VK_BOMB)!=KEY_PUSH)||loops==0)||delay>0){
		DrawObject(objects[36],stgwhite,0,0,640,480,320,240,1,1,ALPHA,dopacity*0.6,8,0,0,0,0,0,0);
		dopacity=lower(255,dopacity+10);
		if((curpage!=page||curchar!=char)&&delay<=0){
			curpage=page;
			curchar=char;
			DrawResultsPage(char,page);
			delay=15;
		}
		if(GetKeyState(VK_LEFT)==KEY_PUSH&&pagetype[page]==1){
			char=(char+6)%7;
			while(!UnlockedCharacters[char]){
				char=(char+6)%7;
			}
			hdir=1;
			redrawstage=true;
			DrawChar(char);
			SE("select");
			yield;
		}
		if(GetKeyState(VK_RIGHT)==KEY_PUSH&&pagetype[page]==1){
			char=(char+1)%7;
			while(!UnlockedCharacters[char]){
				char=(char+1)%7;
			}
			hdir=-1;
			redrawstage=true;
			DrawChar(char);
			SE("select");
			yield;
		}
		if(GetKeyState(VK_UP)==KEY_PUSH){
			page=(page+maxpages-1)%maxpages;
			vdir=1;
			DrawStageName(page);
			SE("select");
			yield;
		}
		if(GetKeyState(VK_DOWN)==KEY_PUSH){
			page=(page+1)%maxpages;
			vdir=-1;
			DrawStageName(page);
			SE("select");
			yield;
		}
		delay--;
		loops++;
		yield;
	}
	vdir=-1;
	hdir=-1;
	stilllooping=false;
	SE("ok");
	yield;
	ClearTextImmediately(19);
	ClearTextImmediately(20);
	ClearTextImmediately(21);
	ClearTextImmediately(22);
	let opacityadd=dopacity/20;
	loop(20){
		DrawObject(objects[36],stgwhite,0,0,640,480,320,240,1,1,ALPHA,dopacity*0.6,8,0,0,0,0,0,0);
		dopacity-=opacityadd;
		yield;
	}
		DrawObject(objects[36],stgwhite,0,0,640,480,320,240,1,1,ALPHA,0,8,0,0,0,0,0,0);
	k=0;
	loop(4){
		DeleteGraphic(GPSD~"img\stage"~IntString(k)~".png");
		k++;
	}
	k=1;
	loop(3){
		DeleteGraphic(GPSD~"img\diff"~IntString(k)~".png");
		k++;
	}

task DrawResultsPage(char,num){
	ClearTextImmediately(21);
	SetFontStyle(0,0,0,0,0,0);
	let charcolors=[[255,100,255],[100,255,100],[100,255,255]];

	let i=0;
	let k=0;
	let color=[];

	let DiffText=["Moon","Planet","Star"];
	if(page==4){
		DiffText=["Extra 1","Extra 2","Extra 3"];
	}
	SetFontColorNew(255,255,255,255,100,255);
	loop(3){
		DrawTextBoldObj(21,"- "~DiffText[k]~" -",imgText,160+320*x[k],30-12+210*y[k],0,4,4,8,0,255,0);
		k++;
	}

	k=0;
	loop(3){
		if(page==4){
			DrawClearThingy2(k,  k,k+10,3,page, true);
		}else{
			DrawClearThingy2(k,  char,num,k,page, false);
		}
		k++;
	}

	let timesplayed=0;
	let score=0;

	loop(5){
		color=RainbowArray((4-i)*50,150,100-i*20);
		loop(3){
			yield;
		}

		SetFontColorNew(255,255,255,255,255,255);

		SetFontColorEmphasis(255,255,255,color[0],color[1],color[2]);

		k=0;
		loop(3){
			score=GetScoreList(char,num,k)[i];
			if(page==4){
				score=GetScoreList(k,k+10,0)[i];
			}

			DrawTextBoldObj(21,IntString(i+1)~"  #"~FormatScore(score),imgText,50+320*x[k],50+i*29+210*y[k],0,4,4,8,1,255,1);
			k++;
		}
		i++;
	}
	k=0;
	loop(3){
		timesplayed=GetTimesPlayed(char,num,k);
		if(page==4){
			timesplayed=GetTimesPlayed(k,10,3);
		}
		DrawTextBoldObj(21,"Times Played: "~IntString(timesplayed),imgText,160+320*x[k],48+i*29+210*y[k],0,3,3,8,0,255,1);
		k++;
	}
	Wait(5);
}

task DrawClearThingy2(k,char,stage,diff,page, alwaysshow){
	let xpos=70+320*x[k];
	let ypos=30+210*y[k];
	let obj;
	let cleartype=GetClearType(char,stage,diff);
	let alpha=0;
	CreateObj;
	while(curpage==page&&(curchar==char||alwaysshow)&&stilllooping){
		alpha+=(1-alpha)/5;
		Obj_Delete(obj);CreateObj;
		yield;
	}
	loop(40){
		alpha+=(0-alpha)/10;
		Obj_Delete(obj);CreateObj;
		yield;
	}
	Obj_Delete(obj);
	sub CreateObj{
		obj=InitEffect(xpos,ypos,imgCharselect,4,ALPHA,8);
		ObjEffect_SetXYRect(obj,-50,-36,50,36);
		ObjEffect_SetUVRect(obj,100*cleartype,412,100+100*cleartype,484);
		ObjEffect_SetScale(obj,alpha,alpha);
		Obj_SetColor(obj,4,alpha*255,255,255,255);
	}
}

task DrawStageName(num){
	let graphics=[0,1,2,3,0];
	let obj=InitEffect(32,50,GPSD~"img\stage"~IntString(graphics[num])~".png",4,ALPHA,8);
	ObjEffect_SetXYRect(obj,0,10,256,160);
	ObjEffect_SetUVRect(obj,0,0,256,150);
	let alpha=0;
	let keeplooping=true;
	let vdirsave=vdir;
	let loops=20;
	ClearTextImmediately(22);
	let extratext=["Full Game","","","","Extra Stages"];
	SetFontStyle(0,0,0,0,0,0);
	SetFontColorNew(0,0,0,0,0,0);
	DrawTextBoldObj(22,extratext[num],imgText,155+2,155+2,0,2.8,2.8,8,0,200,1);
	SetFontColorNew(255,255,255,255,180,180);
	DrawTextBoldObj(22,extratext[num],imgText,155,155,0,2.8,2.8,8,0,255,1);
	loop(10){
		if(!((num==page)&&stilllooping)){
			keeplooping=false;
		}
		if(keeplooping){
			alpha+=255/10;
			Obj_SetColor(obj,4,alpha,255,255,255);
			Obj_SetY(obj,45-(255-alpha)/2*vdirsave);
			loops--;
			yield;
		}
	}
	while((num==page)&&stilllooping){
		if(redrawstage){
			Obj_Delete(obj);
			obj=InitEffect(32,45,GPSD~"img\stage"~IntString(num)~".png",4,ALPHA,8);
			ObjEffect_SetXYRect(obj,0,10,256,160);
			ObjEffect_SetUVRect(obj,0,0,256,150);
			ClearTextImmediately(22);
			SetFontStyle(0,0,0,0,0,0);
			SetFontColorNew(0,0,0,0,0,0);
			DrawTextBoldObj(22,extratext[num],imgText,155+2,155+2,0,2.8,2.8,8,0,200,0);
			SetFontColorNew(255,255,255,255,180,180);
			DrawTextBoldObj(22,extratext[num],imgText,155,155,0,2.8,2.8,8,0,255,0);

			redrawstage=false;
		}
		yield;
	}
	vdirsave=vdir;
	let alphaadd=alpha/loops;
	let y=Obj_GetY(obj);
	let yadd=(128-(y-45))/loops;
	loop(loops){
		alpha-=alphaadd;
		y+=yadd*vdirsave;
		Obj_SetColor(obj,4,alpha,255,255,255);
		Obj_SetY(obj,y);
		yield;
	}
	Obj_Delete(obj);
}
task DrawChar(num){
	let chargfx=[0,250,500,0,0,0,750];	//left bound of graphic
	let charoffset=[-20,-10,10,0,0,0,10];

	let obj=InitEffect(320,240,imgCharselect,4,ALPHA,8);
	ObjEffect_SetXYRect(obj,-125,-190,125,170);
	ObjEffect_SetUVRect(obj,chargfx[num],0,250+chargfx[num],350);
	ObjEffect_SetScale(obj,1,1);
	let alpha=0;
	let keeplooping=true;
	let hdirsave=hdir;
	let loops=20;
	let mult=1;
	loop(10){
		if(!((num==char)&&stilllooping)){
			keeplooping=false;
		}
		if(keeplooping){
			alpha+=255/10;
			Obj_SetColor(obj,4,alpha*0.85,255,255,255);
			Obj_SetX(obj,320-(255-alpha)/2*hdirsave+charoffset[num]);
			loops--;
			yield;
		}
	}
	while((num==char)&&stilllooping){
		yield;
		mult+=(pagetype[page]-mult)/10;
		Obj_SetColor(obj,4,alpha*0.85*mult,255,255,255);
	}
	hdirsave=hdir;
	let alphaadd=alpha/loops;
	let x=Obj_GetX(obj)-charoffset[num];
	let xadd=(128-(x-320))/loops;
	loop(loops){
		alpha-=alphaadd;
		x+=xadd*hdirsave;
		Obj_SetColor(obj,4,alpha*0.85*mult,255,255,255);
		Obj_SetX(obj,x+charoffset[num]);
		yield;
	}
	Obj_Delete(obj);
}
task DrawDiffThingBG(num,graphic,showpage,r,g,b){
	let obj=InitEffect(160+320*x[num],120+220*y[num] ,GPSD~"img\diff"~IntString(graphic)~".png",4,ALPHA,8);
	ObjEffect_SetScale(obj,1.5,1.5);
	ObjEffect_SetXYRect(obj,-64,-64,64,64);
	ObjEffect_SetUVRect(obj,0,0,128,128);
	let alpha=0;
	let mult=0;
	alpha=255;
	ObjEffect_SetColor(obj,4,alpha,255,255,255);
	while(stilllooping){
		ObjEffect_SetColor(obj,4,alpha*mult,r,g,b);
		mult+=((pagetype[page]==showpage)-mult)/10;
		yield;
	}
	loop(10){
		alpha-=255/10;
		ObjEffect_SetColor(obj,4,alpha*mult,r,g,b);
		yield;
	}
	Obj_Delete(obj);
}
}
function FormatScore(num){
	let string=IntString(num);
	let len=length(string);
	let len2=len;
	while(len2>3){
		string=string[0..len2-3]~","~string[len2-3..len];
		len=length(string);
		len2-=3;
	}
	while(len<13){
		string=" "~string;
		len++;
	}
	return string;
}

function GetScoreList(char,stage,diff){
	return GetCommonDataDefault("HISCORE-"~IntString(char)~"-"~IntString(stage)~"-"~IntString(diff),[500000,400000,300000,200000,100000]);
}
function SaveScore(score,char,stage,diff){
	let scorelist=GetScoreList(char,stage,diff);
	let i=4;
	if(IsInfiniteLives==0){
		if(score>scorelist[0]){
			i=0;
		}else{
			while(score>scorelist[i]){
				i--;
			}
			i++;	// i is now the rank of that score, 0 (first place) to 5 (not ranked)
		}
		if(i<5){
			scorelist=scorelist[0..i]~[score]~scorelist[i..4];
			SetCommonData("HighScoreUpdate",true);
		}
		SetCommonData("HISCORE-"~IntString(char)~"-"~IntString(stage)~"-"~IntString(diff),scorelist);
		SaveCommonData;
	}else{
		return 5;
	}
	return i;
}

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

function PlayCredits{
	let deleteeverything=false;
	ClearByteCodeCash;
	CreditsMusic;
	DisableBG;
	ForbidShot2(true);
	CreditsBGBlack;
	CreditsBG(0.5,1,0,255,0);
	CreditsBG(-0.5,-1.2,90,150,123);
	CreditsBG(0,0.5,-45,150,246);
	Wait(121);

	let replay=-1;

	let line=35;
	CreditsLine("Another World's Chaos",			0,line,50,255,70,1, 0, 1);loop(30){yield;}
	CreditsLine("(Demo Version)",				0,line,40,255,70,1, 0, 2.3);loop(70){yield;}

	CreditsLine("Keyboard Tapper, Sparkly Creator,",	0,line,35,255,70,0, 1, 1);loop(30){yield;}
	CreditsLine("Harmonious Air Vibrator, and",		0,line,35,255,70,0, 1, 1);loop(30){yield;}
	CreditsLine("Background Doodler:",			0,line,35,255,70,0, 1, 1);loop(30){yield;}
	CreditsLine("Azure Lazuline",				0,line,45,255,70,1, 2, 2.3);loop(70){yield;}

	CreditsLine("Biological Engineer, Cute Fluffy",		0,line,35,255,70,0, 1, 1);loop(30){yield;}
	CreditsLine("Thing Sketcher, Nonsense Writer,",		0,line,35,255,70,0, 1, 1);loop(30){yield;}
	CreditsLine("Universe Creator, and Love Maker:",	0,line,35,255,70,0, 1, 1);loop(30){yield;}
	CreditsLine("Raibys",					0,line,45,255,70,1, 3, 2.3);loop(70){yield;}

	CreditsLine("Original \Touhou Project\ Concept:",	0,line,35,255,70,0, 1, 1);loop(30){yield;}
	CreditsLine("ZUN",					0,line,45,255,70,1, 0, 2);loop(70){yield;}


	CreditsLine("Other Awesome People:",			0,line,45,255,70,1, 1, 1);loop(40){yield;}
	CreditsLine("Manaqua,",					-4,line,35,255,70,0, 4, 0);
	CreditsLine("Taeral,",					4.5,line,35,255,70,0, 5, 1);loop(40){yield;}
	CreditsLine("and all test player",			0,line,35,255,70,0, 6, 1);loop(40){yield;}

	let pressed=false;

	Wait(100);
	loop(60){
		if(GetKeyState(VK_SHOT)==KEY_PUSH&&pressed==false){
			pressed=true;
			SE("ok");
		}
		yield;
	}
	while(pressed==false){
		if(GetKeyState(VK_SHOT)==KEY_PUSH&&pressed==false){
			pressed=true;
			SE("ok");
		}
		yield;
	}
	replay=0;
	Wait(100);
	replay=ReplayScreen(0,0,false,false);
//	Obj_Delete(obj);

	let obj=InitEffect(-5,-5,stgwhite,4,ADD,8);
	ObjEffect_SetXYRect(obj,0,0,660,500);
	ObjEffect_SetUVRect(obj,0,0,600,600);
	let alpha=0;
	let color=0;
	loop(140){
		alpha+=255/60;
		if(alpha>100){color+=255/90;}
		Obj_SetColor(obj,4,lower(alpha,255),255,color,255);
		yield;
	}
	deleteeverything=true;
	Wait(10);

	if(replay==0){ClearedGame=1;yield;}
	else{Retry;yield;}


	task DisableBG{
		loop{
			drawbackground=false;
			yield;
		}
	}


	task CreditsLine(string,xoffset,y,size,alpha,alphaadd,num,maincolor,linebreaks){
		line+=size*0.5*linebreaks;
		let len=length(string);
		let powlen=power2min(len*16);
		let offset=0;
		let speed=0;
//		if(num>0){
//			CreditsLine(string,y,size,color1,color2,alpha-alphaadd,alphaadd,num-1,maincolor, 0);
//			//yield;
//		}

		//let obj=DrawTextNewObj(0,string,imgText,GetCenterX,y,0,3,3,7,0,255,0);

		let numsections=upper(ceil(len*Detail(0.9,0.7,0.5)),5);

		let target=ImageText(0,string,0,255,255,255);
		let obj=InitEffect(GetCenterX+xoffset*(16*(size/54)),y,target,(numsections+1)*2,ALPHA,7);
		ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLESTRIP);

		ObjEffect_SetScale(obj,size/54,size/50);

		let k=0;
		let i=-(numsections);

		loop(numsections+1){
			ObjEffect_SetVertexUV(obj,k  ,((k/2)/numsections)*powlen,0);
			ObjEffect_SetVertexUV(obj,k+1,((k/2)/numsections)*powlen,32);
			k+=2;
			i+=2;
		}

		CreditsLineAppear;

		i=0;
		let frame=0;
		let x=0;
		let y=0;
		let j=0;
		let xwave=[0,0,0];
		let ywave=[0,0,0];
		let wavelength=[0,0,0];
		let wavetemp;
		loop(3){
			wavelength[i]=rand(0.5,2);
			xwave[i]=rand(1,2)*RandDir;
			ywave[i]=rand(1,2)*RandDir;
			i++;
		}
		loop{
			k=0;
			i=-(numsections);

			loop(numsections+1){
				x=0;
				y=0;
				j=0;
				loop(3){
					wavetemp=sin(frame+k*(360/numsections)*wavelength[j]);
					x+=wavetemp*xwave[j]*offset;
					y+=wavetemp*ywave[j]*offset;
					j++;
				}
				ObjEffect_SetVertexXY(obj,k  ,((i/2)/numsections)*powlen+x,0+y);
				ObjEffect_SetVertexXY(obj,k+1,((i/2)/numsections)*powlen+x,32+y);
				i+=2;
				k+=2;
			}
			frame+=speed;
			yield;
		}

		task CreditsLineAppear{
			let color=[[50,50,50],[255,100,255],[100,200,255],[100,255,100],[100,100,255],[255,255,100],[255,100,100]][maincolor];


			let frame=0;
			let percent=0;
			let time=280;
			let k=0;
			loop(time){
				percent=cos(frame*(180/time))/2+0.5;
				speed=1+percent*4;
				offset=1+percent*70;
				frame++;
				CreditsSetColor;
				yield;
			}
			while(replay==-1){
				frame++;
				CreditsSetColor;
				yield;
			}
			time=400;
			let frame2=time;
			loop(time){
				percent=cos(frame2*(180/time))/2+0.5;
				speed=1+percent*4;
				offset=1+percent*50;
				frame2--;
				frame++;
				CreditsSetColor;
				if(!deleteeverything){
					yield;
				}
			}
			Obj_Delete(obj);
			DeleteGraphic(target);

			sub CreditsSetColor{
				k=0;
				loop(numsections+1){
					if(maincolor==0){
						color=RainbowArray(k*15*(1/Detail(0.9,0.7,0.5))+frame*3*Detail(0.9,0.7,0.5),255,0);
					}
					ObjEffect_SetVertexColor(obj,k  ,lower((1-percent)*600,255), 255,255,255);
					ObjEffect_SetVertexColor(obj,k+1,lower((1-percent)*600,255), color[0],color[1],color[2]);
					k+=2;
				}
			}
		}

	}

	task CreditsBGBlack{
		let obj=InitEffect(GetCenterX,GetCenterY,stgwhite,4,ALPHA,4);
		ObjEffect_SetXYRect(obj,-300,-300,300,300);
		ObjEffect_SetUVRect(obj,0,0,600,600);
		Obj_SetColor(obj,4,255,0,0,0);
	}
	task CreditsBG(xscroll,yscroll,angle,alpha,frame){
		let obj=InitEffect(GetCenterX,GetCenterY,GPSD~"img\soulfill.png",4,ALPHA,4);
		Obj_SetColor(obj,4,alpha,255,255,255);
		ObjEffect_SetAngle(obj,0,0,angle);
		ObjEffect_SetXYRect(obj,-300,-300,300,300);
		let x=0;
		let y=0;
		let color=[0,0,0];
		loop{
			ObjEffect_SetUVRect(obj,x,y,x+600,y+600);
			frame++;
			if(frame%9==0){
				color=RainbowArray(frame,100,155);
			}
			Obj_SetColor(obj,4,alpha,color[0],color[1],color[2]);
			x+=xscroll*2;
			y+=yscroll*2;
			yield;
		}
	}
}

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

task Sparkle(x,y,v,angle,size,time,alpha){
	let obj=InitEffect(x,y,imgEffects,4,ADD,8);
	ObjEffect_SetXYRect(obj,-32,-32,32,32);
	ObjEffect_SetUVRect(obj,128,1,191,63);
	let graphicangle=rand(0,360);
	let angvel=rand(-10,10);
	let sizeadd=size/time;
	let xvel=cos(angle)*v;
	let yvel=sin(angle)*v;
	Obj_SetColor(obj,4,alpha,255,255,255);
	loop(time){
		ObjEffect_SetAngle(obj,0,0,graphicangle);
		ObjEffect_SetScale(obj,size,size);
		Obj_SetPosition(obj,x,y);
		graphicangle+=angvel;
		size-=sizeadd;
		x+=xvel;
		y+=yvel;
		yield;
	}
	Obj_Delete(obj);
}

function center(num1,num2,num3){
//returns the middle number
	return lower(upper(num1,num2),num3)
}

function rainbow(color,offset){
	return center(0,sin((offset-(color*120)+70))+0.5,1);
}

function WrapText(text, spaces){
	text=text~" ";
	let strings=[];
	let numstrings=0;
	let k=0;
	let lastletter=1;
	while(length(text)>0&&lastletter>0){
		lastletter=0;
		k=0;
		while(k<spaces&&k<length(text)){
			if(text[k]==' '){lastletter=k;}
			if(text[k]=='^'){
				text[k]=' ';	//add a newline
				k=spaces;
			}
			k++;
		}
		strings=strings~[text[0..lower(lastletter,length(text))]];
		text=text[lower(lastletter+1,length(text))..length(text)];
		numstrings++;
	}

	return strings;
}
task MenuItemDelay(item,delay){
	loop(delay){yield;}
	menuitem=item;
}
