 let imgBorder=GPSD~"img\frame.png";
 let imgFiller=GPSD~"img\soulfill.png";
 let difftexture="";

task InitBorder(drawextras){
	SetDefaultStatusVisible(false);
	yield;
	DrawDifficultyThingie;
	DrawBorderMain;
	if(IsInfiniteLives==0){
		DrawLivesBombs(0);
	}else if(GetCommonDataDefault("Stagenum",-2)!=-1){
		DrawDeathCounter(IsInfiniteLives);
	}
	if(GetPlayer!=6){
		DrawLivesBombs(1);
	}
	DrawCounters(drawextras);
	InitSoulCounter;
	DrawNullity;
	DrawFPS;
}
sub DrawDifficultyThingie{
	let textures=["diff1.png","diff2.png","diff3.png","diff4.png"];
	let xoffset=[-5,-5,0,-10];
	difftexture=GPSD~"img\"~textures[GetCommonDataDefault("Diff",0)];
	LoadGraphic(difftexture);
	let obj = Obj_Create(OBJ_EFFECT);
	Obj_SetPosition(obj, 450+xoffset[GetCommonDataDefault("Diff",0)],55);
	Obj_SetSpeed(obj, 0);
	Obj_SetAngle(obj, 0);
	ObjEffect_SetTexture(obj,difftexture);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
	ObjEffect_SetScale(obj,1.5,1.5);
	ObjEffect_SetAngle(obj,0,0,0);
	ObjEffect_SetLayer(obj,8);
	ObjEffect_CreateVertex(obj,4);
	ObjEffect_SetRenderState(obj,ALPHA);
	Obj_SetAutoDelete(obj,false);

	ObjEffect_SetVertexXY(obj,0,  0,0);
	ObjEffect_SetVertexXY(obj,1,128,0);
	ObjEffect_SetVertexXY(obj,2,128,128);
	ObjEffect_SetVertexXY(obj,3,  0,128);
	ObjEffect_SetVertexUV(obj,0,  0,0);
	ObjEffect_SetVertexUV(obj,1,127,0);
	ObjEffect_SetVertexUV(obj,2,127,127);
	ObjEffect_SetVertexUV(obj,3,  0,127);

}
function DrawBorderMain{
    let obj = Obj_Create(OBJ_EFFECT);
    Obj_SetPosition   (obj, 420,60);
    Obj_SetSpeed      (obj, 0);
    Obj_SetAngle(obj, 0);
    ObjEffect_SetTexture(obj,imgBorder);
    ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
    ObjEffect_SetScale(obj,1,1);
    ObjEffect_SetAngle(obj,0,0,0);
    ObjEffect_SetLayer(obj,8);
    ObjEffect_CreateVertex(obj,4);
    ObjEffect_SetRenderState(obj,ALPHA);
    Obj_SetAutoDelete(obj,false);

    ObjEffect_SetVertexXY(obj,0, 0,0);
    ObjEffect_SetVertexXY(obj,1,220,0);
    ObjEffect_SetVertexXY(obj,2,220,180);
    ObjEffect_SetVertexXY(obj,3, 0,180);
    ObjEffect_SetVertexUV(obj,0, 0,0);
    ObjEffect_SetVertexUV(obj,1,220,0);
    ObjEffect_SetVertexUV(obj,2,220,180);
    ObjEffect_SetVertexUV(obj,3, 0,180);
}
task DrawLivesBombs(lifebomb){
	let obj=Obj_Create(OBJ_EFFECT);
	Obj_SetSpeed(obj, 0);
	Obj_SetAngle(obj, 0);
	ObjEffect_SetTexture(obj,imgBorder);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
	ObjEffect_SetScale(obj,1,1);
	ObjEffect_SetAngle(obj,0,0,0);
	ObjEffect_SetLayer(obj,8);
	ObjEffect_CreateVertex(obj,4);
	ObjEffect_SetRenderState(obj,ALPHA);
	Obj_SetAutoDelete(obj,false);
	Obj_SetPosition(obj,420,65+24*lifebomb);

	ObjEffect_SetVertexXY(obj,0,85,130);
	ObjEffect_SetVertexXY(obj,3,85,150);
	ObjEffect_SetVertexUV(obj,0,85,185+24*lifebomb);
	ObjEffect_SetVertexUV(obj,3,85,205+24*lifebomb);

	let current=0;
	loop{
		if( (current!=GetPlayerLife-101&&lifebomb==0) || (current!=GetPlayerBomb&&lifebomb==1) ){
			current=GetPlayerLife-101;
			if(lifebomb==1){
				current=GetPlayerBomb;
			}else{
				if(current==-1){
					ContinueScreen;
				}
			}
			ObjEffect_SetVertexXY(obj,1,85+18*upper(current,0),130);
			ObjEffect_SetVertexXY(obj,2,85+18*upper(current,0),150);
			ObjEffect_SetVertexUV(obj,1,85+18*upper(current,0),185+24*lifebomb);
			ObjEffect_SetVertexUV(obj,2,85+18*upper(current,0),205+24*lifebomb);
		}
		loop(2){yield;}
	}
}
task DrawDeathCounter(num){

	let obj=InitEffect(635,219,imgBorder,4,ALPHA,8);
	ObjEffect_SetAngle(obj,0,0,90);
	ObjEffect_SetXYRect(obj,-25,0,0,130);
	ObjEffect_SetUVRect(obj,-25,0,0,130);	//draw the cross

	if(num>1){

		num=-1000;
		let num2;
		let num3;
		let k=0;
		let digits=0;
		let sign=0;
		obj=InitEffect(570,219-21,imgBorder,18,ALPHA,8);
		ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLESTRIP);
		loop{
			if(num!=center(-99,GetPlayerLife-10000+totallives,99)){
				num=center(-99,GetPlayerLife-10000+totallives,99);
				num2=num;
				k=0;
				digits=2;
				if(num2>0){
					sign=1;
				}
				else if(num2<0){
					sign=-1;
					num2=-num2;
				}
				loop(3){
					if(num2==0&&k!=0){
						if(sign>0){
							num3=13;
							sign=0;
						}else if(sign<0){
							num3=12;
							sign=0;
						}else{
							num3=-1;
						}
						digits--;
					}else{
						num3=num2%10;
					}
					ObjEffect_SetVertexXY(obj,0+k*6,-6-k*12,0);
					ObjEffect_SetVertexXY(obj,1+k*6, 7-k*12,0);
					ObjEffect_SetVertexXY(obj,2+k*6, 7-k*12,17);
					ObjEffect_SetVertexXY(obj,3+k*6,-6-k*12,17);
					ObjEffect_SetVertexXY(obj,4+k*6,-6-k*12,0);
					ObjEffect_SetVertexXY(obj,5+k*6, 7-k*12,0);
					ObjEffect_SetVertexUV(obj,0+k*6,num3*13   ,239);
					ObjEffect_SetVertexUV(obj,1+k*6,num3*13+13,239);
					ObjEffect_SetVertexUV(obj,2+k*6,num3*13+13,256);
					ObjEffect_SetVertexUV(obj,3+k*6,num3*13   ,256);
					ObjEffect_SetVertexUV(obj,4+k*6,num3*13   ,239);
					ObjEffect_SetVertexUV(obj,5+k*6,num3*13+13,239);
					num2=trunc(num2/10);	//get next digit
					k++;
					Obj_SetX(obj,570+digits*6);
				}
			}
			yield;
		}
	}
}

task DrawCounters(drawextras){

	let obj=InitCounter(0);
	let obj2=InitCounter(1);
	let obj3=InitCounter(1);
	ObjEffect_SetLayer(obj3,8);
	Obj_SetPosition(obj3,631-128,69-25);
	Obj_SetColor(obj3,4,220,180,180,255);

	let obj4=InitEffect(497,41,imgBorder,4,ALPHA,8);
	ObjEffect_SetXYRect(obj4,0,0,24,68);
	ObjEffect_SetUVRect(obj4,226,160,250,228);
	ObjEffect_SetAngle(obj4,0,0,90);
	Obj_SetColor(obj4,4,200,180,180,255);
	if(!IsAWCPlayer||!drawextras||IsReplay){
		ObjEffect_SetUVRect(obj3,0,0,1,1);ObjEffect_SetXYRect(obj3,0,0,1,1);	//don't draw high score
		ObjEffect_SetUVRect(obj4,0,0,1,1);ObjEffect_SetXYRect(obj4,0,0,1,1);
	}
	if(!drawextras){
		Obj_SetY(obj2,-100);
	}

	CreateRenderTarget("statusbar",512,512);
	ClearRenderTarget("statusbar");
	let previous=[-1,-1,-1,-1];
	let update=false;
	let update2=false;
	let update3=true;
	let y=0;
	loop{
		update=false;
		update2=false;
		if(GetScore!=previous[0]){
			previous[0]=GetScore;
			update=true;
		}
		if(GetGraze!=previous[1]){
			previous[1]=GetGraze;
			update=true;
		}
		if(GetPoint!=previous[2]){
			previous[2]=GetPoint;
			update=true;
		}
		if(GetCommonDataDefault("MaxPoint",0)!=previous[3]){
			previous[3]=GetCommonDataDefault("MaxPoint",0);
			update=true;
			update2=true;
		}
		if(update){
			DrawCounter2;
			ObjEffect_SetTexture(obj,"statusbar");
			ObjEffect_SetUVRect(obj,0,25,128,100);
			if(update2){
				ObjEffect_SetTexture(obj2,"statusbar");
				ObjEffect_SetUVRect(obj2,0,100,128,125);
			}
		}
		if(update3||GetCommonDataDefault("HighScoreUpdate",false)){
			DrawCounter2;
			ObjEffect_SetTexture(obj3,"statusbar");
			ObjEffect_SetUVRect(obj3,0,0,128,25);
			update3=false;
			DeleteCommonData("HighScoreUpdate");
		}
		loop(3){
			if(IsForbidBomb&&y<1){
				y+=1/12;
				Obj_SetPosition(obj2,GetClipMaxX-128,GetClipMaxY-3-25+y*5);
			}
			if(!IsForbidBomb&&y>0){
				y-=1/12;
				Obj_SetPosition(obj2,GetClipMaxX-128,GetClipMaxY-3-25+y*5);
			}
			yield;
		}
	}

}
function InitCounter(num){
	let obj=Obj_Create(OBJ_EFFECT);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
	ObjEffect_CreateVertex(obj,4);
	Obj_SetAutoDelete(obj,false);

	if(num==0){
		ObjEffect_SetLayer(obj,8);
		Obj_SetPosition(obj,635-132,65);
		ObjEffect_SetXYRect(obj,0,0,128,75);
	}else{
		ObjEffect_SetLayer(obj,2);
		Obj_SetPosition(obj,GetClipMaxX-128,GetClipMaxY+2-25);
		ObjEffect_SetXYRect(obj,0,0,128,25);
	}

	return obj;
}

function InitLifeObj(digits,y){

	let obj=Obj_Create(OBJ_EFFECT);
	Obj_SetSpeed(obj, 0);
	Obj_SetAngle(obj, 0);
	ObjEffect_SetTexture(obj,imgBorder);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLESTRIP);
	ObjEffect_SetScale(obj,1,1);
	ObjEffect_SetAngle(obj,0,0,0);
	ObjEffect_SetLayer(obj,8);
	ObjEffect_CreateVertex(obj,6*(digits));
	ObjEffect_SetRenderState(obj,ALPHA);
	Obj_SetAutoDelete(obj,false);
	Obj_SetPosition(obj,635-digits*13,62+y*25);
	let ii=0;
	let char=0;
	let minx=0;
	return obj;
}
function DrawCounter2{
	let row=0;

	let highscore=0;
	if(!IsAWCPlayer){
		row=1;	//skip drawing high score
	}else{
		if(fullgame==1){
			highscore=GetScoreList(GetPlayer,0,diff)[0];
		}else if(stage>=10){
			highscore=GetScoreList(GetPlayer,GetPlayer+10,diff)[0];
		}else{
			highscore=GetScoreList(GetPlayer,stage,diff)[0];
		}

	}

	ClearRenderTarget("statusbar");
	let numbers=[highscore,GetScore,GetGraze,GetPoint,GetCommonDataDefault("MaxPoint",0)+5000];
	let prevtarget=SetRenderTarget("statusbar");
	let num;

	SetGraphicScale(1,1);
	SetGraphicAngle(0,0,0);
	SetColor(255,255,255);
	SetAlpha(255);
	SetTexture(imgBorder);
	let xoffset;
	let scale;
	let kerning;
	let commaoffset;
	loop(5-row){
		scale=[12/13,1,1,1,0.75][row];
		kerning=[2,-1,-1,-1,3][row];
		commaoffset=[-2,0,0,0,-2][row];
		SetGraphicScale(scale,scale);
		xoffset=0;
		let i=0;
		if(row==3){
			SetColor(150,255,150);
			num=nextbombpoint;
			while(num>0){
				SetGraphicRect((num%10)*13,238,(num%10*13)+13,256);
				DrawGraphic(round(128-7-i*10+xoffset+i*kerning),row*25+10);
				num=trunc(num/10);	//get next digit
				i++;
			}
			xoffset=-i*10-10;
			SetGraphicRect(11*13,235,(11*13)+13,256);
			SetColor(200,255,200);
			DrawGraphic(round(133+xoffset+i*kerning),row*25+9);
			SetColor(255,255,255);
		}

		i=0;
		num=numbers[row];
		if(num>=1000000000){
			kerning++;
		}
		while(num>0||i==0){
			if(i%3==0&&i>0&&row!=3){
				SetGraphicRect(10*13,238,(10*13)+13,256);
				DrawGraphic(round(128-i*11+xoffset+i*kerning+commaoffset),row*25+11);
				xoffset-=4*scale;
			}
			SetGraphicRect((num%10)*13,238,(num%10*13)+13,256);
			DrawGraphic(round(128-7-i*11+xoffset+i*kerning),row*25+10);
			num=trunc(num/10);	//get next digit
			i++;
		}

		row++;
	}
	SetRenderTarget(prevtarget);
}

task DrawNullity{
	let obj=Obj_Create(OBJ_EFFECT);
	Obj_SetSpeed(obj, 0);
	Obj_SetAngle(obj, 0);
	ObjEffect_SetTexture(obj,imgBorder);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLEFAN);
	ObjEffect_SetScale(obj,1,1);
	ObjEffect_SetAngle(obj,0,0,0);
	ObjEffect_SetLayer(obj,8);
	ObjEffect_CreateVertex(obj,4);
	ObjEffect_SetRenderState(obj,ALPHA);
	Obj_SetAutoDelete(obj,false);
	ObjEffect_SetAngle(obj,0,0,90);

	ObjEffect_SetVertexXY(obj,0,-25,0);
	ObjEffect_SetVertexXY(obj,1,0,0);
	ObjEffect_SetVertexXY(obj,2,0,130);
	ObjEffect_SetVertexXY(obj,3,-25,130);
	ObjEffect_SetVertexUV(obj,0,-25,0);
	ObjEffect_SetVertexUV(obj,1,0,0);
	ObjEffect_SetVertexUV(obj,2,0,130);
	ObjEffect_SetVertexUV(obj,3,-25,130);

	Obj_SetPosition(obj,635*IsForbidBomb,243);

	if(IsAWCPlayer&&GetPlayer==6){
		Obj_SetPosition(obj,635,243);
	}else{
		let appearance=IsForbidBomb;
		loop{
			if(IsForbidBomb!=appearance){
				appearance=IsForbidBomb;
				Obj_SetPosition(obj,635*IsForbidBomb,243);
			}
			yield;
			yield;
			yield;
		}
	}
}

function DrawNumber(obj,digits,num){
	let ii=digits-1;	//actual position
	let minx=ii*13;
	let char=0;
	let realdigits=0;
	loop(digits){
		char=(num%10)*13;
		if(num==0&&ii!=digits-1){char=-13;}
		if(num>0||realdigits==0){realdigits++;}
		num=trunc(num/10);

		ObjEffect_SetVertexXY(obj,(ii*6)  ,minx,0);
		ObjEffect_SetVertexXY(obj,(ii*6)+1,minx,0);
		ObjEffect_SetVertexXY(obj,(ii*6)+2,minx+13,0);
		ObjEffect_SetVertexXY(obj,(ii*6)+3,minx,22);
		ObjEffect_SetVertexXY(obj,(ii*6)+4,minx+13,22);
		ObjEffect_SetVertexXY(obj,(ii*6)+5,minx+13,22);

		ObjEffect_SetVertexUV(obj,(ii*6)  ,char+0 ,256-22);
		ObjEffect_SetVertexUV(obj,(ii*6)+1,char+0 ,256-22);
		ObjEffect_SetVertexUV(obj,(ii*6)+2,char+13,256-22);
		ObjEffect_SetVertexUV(obj,(ii*6)+3,char+0 ,256);
		ObjEffect_SetVertexUV(obj,(ii*6)+4,char+13,256);
		ObjEffect_SetVertexUV(obj,(ii*6)+5,char+13,256);

		minx-=13;
		if((digits-ii)%3==0){minx-=2;}
		ii--;
	}
	return realdigits;
}
function CenterNumber(obj,digits,x,y){		//made just for drawing underneath the bars, will not center correctly otherwise
	Obj_SetPosition(obj,x+digits*5,y);
}

let soulmet=[0,0,0,0,0];
let soulobj=[0,0,0,0,0];
let soulpercent=[0,0,0,0,0];
let soulscroll=0;
let soulcounter=[0,0,0,0,0];

task InitSoulCounter{
	let kk=0;
	loop(5){
		soulmet[kk]=Obj_Create(OBJ_EFFECT);
		ObjEffect_SetTexture(soulmet[kk],imgFiller);
		ObjEffect_SetPrimitiveType(soulmet[kk],PRIMITIVE_TRIANGLEFAN);
		ObjEffect_SetScale(soulmet[kk],1,1);
		ObjEffect_SetAngle(soulmet[kk],0,0,0);
		ObjEffect_SetLayer(soulmet[kk],8);
		ObjEffect_CreateVertex(soulmet[kk],4);
		ObjEffect_SetRenderState(soulmet[kk],ADD);
		Obj_SetAutoDelete(soulmet[kk],false);
		Obj_SetPosition(soulmet[kk],450+kk*40,178);
//		if(kk==4){
//			Obj_SetPosition(soulmet[kk],457+kk*40,178);
//		}

		if(kk<4){
			soulobj[kk]=Obj_Create(OBJ_EFFECT);
			ObjEffect_SetTexture(soulobj[kk],imgItems);
			ObjEffect_SetPrimitiveType(soulobj[kk],PRIMITIVE_TRIANGLEFAN);
			ObjEffect_SetScale(soulobj[kk],1,1);
			ObjEffect_SetAngle(soulobj[kk],0,0,0);
			ObjEffect_SetLayer(soulobj[kk],8);
			ObjEffect_CreateVertex(soulobj[kk],4);
			ObjEffect_SetRenderState(soulobj[kk],ALPHA);
			Obj_SetAutoDelete(soulobj[kk],false);
			Obj_SetPosition(soulobj[kk],451+kk*40,175);
			let size=20;

			ObjEffect_SetVertexXY(soulobj[kk],0,-size,-size*2+2);
			ObjEffect_SetVertexXY(soulobj[kk],1, size,-size*2+2);
			ObjEffect_SetVertexXY(soulobj[kk],2, size, 0);
			ObjEffect_SetVertexXY(soulobj[kk],3,-size, 0);
			ObjEffect_SetVertexUV(soulobj[kk],0,kk*48   ,-47);
			ObjEffect_SetVertexUV(soulobj[kk],1,kk*48+48,-47);
			ObjEffect_SetVertexUV(soulobj[kk],2,kk*48+48,-1);
			ObjEffect_SetVertexUV(soulobj[kk],3,kk*48   ,-1);

		}

		SoulPercent(kk,0);
		ObjEffect_SetVertexXY(soulmet[kk],2, 15, 0);
		ObjEffect_SetVertexXY(soulmet[kk],3,-15, 0);

		Soul_SetColor(soulmet[kk],255,kk);

		kk++;
	}
	Soul_SetColor(soulmet[4],255,4);

	let temp=0;

	kk=0;
	loop(5){
		soulcounter[kk]=InitLifeObj(3,0);
		ObjEffect_SetScale(soulcounter[kk],0.75,0.75);
		temp=DrawNumber(soulcounter[kk],3,0);
		CenterNumber(soulcounter[kk],temp,422+kk*40,177);
		kk++;
	}

	loop{
		kk=0;
		loop(5){
			DrawSoul(kk);
			kk++;
		}
		soulscroll+=2;
		yield;
		yield;
	}
}
function UpdateSoulCounter(type){

	let percentage=soulamount[type]/soulmaximum[type];
	SoulPercent(type,percentage);

	let max=GetCommonDataDefault("SoulMax",500);
	SoulPercent(4,(soulamount[4]/max));

	let temp=DrawNumber(soulcounter[type],3,trunc(percentage*100));
	CenterNumber(soulcounter[type],temp,422+type*40,177);

	temp=DrawNumber(soulcounter[4],3,trunc((soulamount[4]/max)*100));
	CenterNumber(soulcounter[4],temp,582,177);
}
function DrawSoul(type){
	let size=30;

	ObjEffect_SetVertexUV(soulmet[type],0,type*30   ,-42*soulpercent[type]+soulscroll);
	ObjEffect_SetVertexUV(soulmet[type],1,type*30+30,-42*soulpercent[type]+soulscroll);
	ObjEffect_SetVertexUV(soulmet[type],2,type*30+30,soulscroll);
	ObjEffect_SetVertexUV(soulmet[type],3,type*30   ,soulscroll);

}
function SoulPercent(type,percent){
	let size=57;

	if(percent>1){percent=1};

	ObjEffect_SetVertexXY(soulmet[type],0,-15,-42*percent);
	ObjEffect_SetVertexXY(soulmet[type],1, 15,-42*percent);

	soulpercent[type]=percent;
}

task DrawFPS{

	let obj=InitEffect(0,0,"img\STG_Frame.png",4,ALPHA,8);
	ObjEffect_SetXYRect(obj,540,450,640,480);
	ObjEffect_SetUVRect(obj,540,450,640,480);	//cover the existing one

	num=-1000;
	let num2;
	let k=0;
	let digits=0;
	let sign=0;
	obj=InitEffect(630,460,imgBorder,24,ALPHA,8);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLESTRIP);
	let num=0;
	loop{
		if(num!=GetFps){
			num=GetFps;
			k=0;
			digits=1;
			if(num>=10){digits=2;}
			if(num>=100){digits=3;}
			loop(3){
				num2=trunc(num)%10;
				if(k<digits){
					ObjEffect_SetVertexXY(obj,0+k*6,-6-k*12,0);
					ObjEffect_SetVertexXY(obj,1+k*6, 7-k*12,0);
					ObjEffect_SetVertexXY(obj,2+k*6, 7-k*12,17);
					ObjEffect_SetVertexXY(obj,3+k*6,-6-k*12,17);
					ObjEffect_SetVertexXY(obj,4+k*6,-6-k*12,0);
					ObjEffect_SetVertexXY(obj,5+k*6, 7-k*12,0);
					ObjEffect_SetVertexUV(obj,0+k*6,num2*13   ,239);
					ObjEffect_SetVertexUV(obj,1+k*6,num2*13+13,239);
					ObjEffect_SetVertexUV(obj,2+k*6,num2*13+13,256);
					ObjEffect_SetVertexUV(obj,3+k*6,num2*13   ,256);
					ObjEffect_SetVertexUV(obj,4+k*6,num2*13   ,239);
					ObjEffect_SetVertexUV(obj,5+k*6,num2*13+13,239);
				}else{
					ObjEffect_SetVertexXY(obj,0+k*6,0,0);
					ObjEffect_SetVertexXY(obj,1+k*6,0,0);
					ObjEffect_SetVertexXY(obj,2+k*6,0,0);
					ObjEffect_SetVertexXY(obj,3+k*6,0,0);
					ObjEffect_SetVertexXY(obj,4+k*6,0,0);
					ObjEffect_SetVertexXY(obj,5+k*6,0,0);
				}
				num=trunc(num/10);	//get next digit
				k++;
			}
		}
		yield;
		yield;
	}
}
