#include_function GCSD~"..\..\text.dnh"

let imgText=GPSD~"img\font.png";
let imgBox=GPSD~"img\box.png";

let texttoclear=[];

let newtextcolor=[255,255,255,255,255,255];
let newtextcolor2=[255,255,255,255,255,255];
let clearimmediately=0;
let textrender=[0,0,0,0];
let textreveal=[0,0];
let objbox=0;
let EventPosO=[0,0,0,0];
let EventPosX=[0,0,0,0];
let EventPosA=[-1,-1,-1,-1];	//-1 = does not exist, 0 = faded out, 1 = active
let EventPosC=["","","",""];	//image
let EventPosL=[0,0,0,0];	//left
let EventPosR=[0,0,0,0];	//right
let EventPosB=[0,0,0,0];	//bottom
let EventPosP=[-1,-1,-1,-1];	//activeness "percentage" (0 to 1) used for fading
let TextY=330;

let sk="**********";

function SetFontColorNew(r1,g1,b1,r2,g2,b2){
//RGB for top, then RGB for bottom
	newtextcolor=[r1,g1,b1,r2,g2,b2];
}
function SetFontColorEmphasis(r1,g1,b1,r2,g2,b2){
	newtextcolor2=[r1,g1,b1,r2,g2,b2];
}
function SetFontStyle(state,shift,angle,angle2,ghostsize,ghostlen){
	textrender=[state,shift,angle,angle2,ghostsize,ghostlen];
}

task ClearText(value) {
	texttoclear=texttoclear~[value];
	yield;
	let i=0;
	let found=false;
	loop(length(texttoclear)){
		if(found==false){
			if(texttoclear[i]==value){
				texttoclear=erase(texttoclear,i);
				found=true;
			}
			i++;
		}
	}
}
task ClearTextImmediately(value) {
	texttoclear=texttoclear~[value+1000];
	yield;
	let i=0;
	let found=false;
	loop(length(texttoclear)){
		if(found==false){
			if(texttoclear[i]==value+1000){
				texttoclear=erase(texttoclear,i);
				found=true;
			}
			i++;
		}
	}
}
task ClearTextHalf(value) {
	texttoclear=texttoclear~[value+2000];
	yield;
	let i=0;
	let found=false;
	loop(length(texttoclear)){
		if(found==false){
			if(texttoclear[i]==value+2000){
				texttoclear=erase(texttoclear,i);
				found=true;
			}
			i++;
		}
	}
}
function IsTextCleared(value){
	let ret=false;
	let i=0;
	loop(length(texttoclear)){
		if(texttoclear[i]==value){ret=true;clearimmediately=0;}
		if(texttoclear[i]==value+1000){ret=true;clearimmediately=1;}
		if(texttoclear[i]==value+2000){ret=true;clearimmediately=0.5;}
		i++;
	}
	return ret;
}

function TextWait(frames){
	let k=0;
	let pushframe=0;
	loop(frames){
		if(GetKeyState(VK_SKIP)==KEY_FREE||GetCommonDataDefault("Skippable",0)==0){
			k+=1;
		}else{
			k+=1/6;
		}
		while(k>0){
			k--;
			pushframe++;
			if(GetKeyState(VK_SHOT)==KEY_PUSH){pushframe=0;}
			yield;
		}
		effectframe++;
	}
	return pushframe;
}
function WaitKey{
	while(GetKeyState(VK_SHOT)!=KEY_PUSH&&GetKeyState(VK_SKIP)==KEY_FREE){effectframe++;yield;}
}

function DrawTextNew(value,string,font,x,y,angle,xsize,ysize,layer,align,alpha,delay){
//string: the string to write
//font: what image file to use
//x,y,angle: obvious
//size: default 1, multiplies the size by that amount
//layer: what layer to draw it on
//align: 1 is left-justified, -1 is right-justified, 0 is centered
//alpha: obvious
//delay: frames between letters, can be a decimal
	let obj=Obj_Create(OBJ_EFFECT);
	DrawTextNewTask(obj,value,string,font,x,y,angle,xsize,ysize,layer,align,alpha,delay,0);
	return length(string)*delay;
}
function DrawTextNewObj(value,string,font,x,y,angle,xsize,ysize,layer,align,alpha,delay){
//same as above, but returns the object
	let obj=Obj_Create(OBJ_EFFECT);
	DrawTextNewTask(obj,value,string,font,x,y,angle,xsize,ysize,layer,align,alpha,delay,0);
	return obj;
}
function DrawTextBoldObj(value,string,font,x,y,angle,xsize,ysize,layer,align,alpha,delay){
//same as above, but darker outlines (for event text)
	let obj=Obj_Create(OBJ_EFFECT);
	DrawTextNewTask(obj,value,string,font,x,y,angle,xsize,ysize,layer,align,alpha,delay,1);
	return obj;
}
function DrawTextNewKana(value,string,font,x,y,angle,xsize,ysize,layer,align,alpha,delay){
	let obj=Obj_Create(OBJ_EFFECT);
	DrawTextNewTask(obj,value,string,font,x,y,angle,xsize,ysize,layer,align,alpha,delay,2);
	return length(string)*delay;
}
function DrawTextNewKanaObj(value,string,font,x,y,angle,xsize,ysize,layer,align,alpha,delay){
	let obj=Obj_Create(OBJ_EFFECT);
	DrawTextNewTask(obj,value,string,font,x,y,angle,xsize,ysize,layer,align,alpha,delay,2);
	return obj;
}
task SetKerning(num){
	textadditionalwidth=num;
	yield;
	textadditionalwidth=0;
}

let renderarray=[ALPHA,ADD,SUBTRACT];
let textadditionalwidth=0;

task DrawTextNewTask(obj,value,string,font,x,y,angle,xsize,ysize,layer,align,alpha,delay,type){
    let kerning=textadditionalwidth;

    let ntc=newtextcolor;
    let ntc1=newtextcolor;
    let ntc2=newtextcolor2;
    let ghostrender=textrender;

    let newstring=[];
    let spacing=[];
    let strlen=0;

    let ii=0;
    let ii2=0;
    let spacingminus=0;

    if(type==2){
	loop(length(string)/2){
		ii2=ToKana(string[ii],string[ii+1]);
		newstring=newstring~[ii2];
		spacing=spacing~[ii/2];
		strlen++;
		ii+=2;
	}
    }else{
	loop(length(string)){
		ii2=ToNumber(string[ii])*32;
		if(ii2>=0){//if not a space
			strlen++;
			newstring=newstring~[ii2];
			if(ii2>=255*32){	// if it's a control character, add it to the list but don't use up any space
				spacingminus++;
			}
			spacing=spacing~[ii-spacingminus];
		}
		ii++;
	    }
    }
    let totalspacing=ii-spacingminus;

    ghostrender[0]=renderarray[ghostrender[0]];
    ghostrender[1]=ghostrender[1]/delay;
    ghostrender[5]=ghostrender[5]*delay;
    yield;

    y+=16;
    xsize=xsize/10;
    ysize=ysize/5;


    let k=0;
    let minx=0;
    let miny=0;
    let string2=[];

    Obj_SetPosition(obj,x,y);
    Obj_SetSpeed      (obj, 0);
    ObjEffect_SetAngle(obj, 0,0,angle);
    ObjEffect_SetTexture(obj,font);
    ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLESTRIP);
    ObjEffect_SetLayer(obj,layer);
    ObjEffect_CreateVertex(obj,strlen*6);
    ObjEffect_SetRenderState(obj,ALPHA);
    ObjEffect_SetScale(obj,xsize,ysize);

    let char=0;

    ii2=0;	//total characters
    ii=0;	//counted characters
    let size=1;
    let size2=1;
    let symboltype=0;
    let xoffsetminus=0;
    loop(strlen){
	if(type<=1){
		char=newstring[ii2];
	}else{
		char=newstring[ii2];
		size=1;
		size2=1;
		symboltype=0;
		if((newstring[ii2]*100%10)>0){//if hundredths digit is not 0
			symboltype=(newstring[ii2]*100)%10;
			newstring[ii2]=(trunc(newstring[ii2]*10))/10;	//remove hundredths digit
		}
		if(newstring[ii2]!=trunc(newstring[ii2])){
			size=0.6;
			size2=0.9;
			xoffsetminus+=2;
		}
		char=trunc(char)*32;
	}
	if(char<(256*32)){
		if(align==-1){
			minx=(spacing[ii]*32)-(totalspacing*32);
		}else if(align==1){
			minx=(spacing[ii]*32);
		}else{
			minx=(spacing[ii]*32)-(totalspacing*16);
		}
		if(type<=1){
			ObjEffect_SetVertexXY(obj,(ii*6)  ,minx-16-kerning,-16*size);
			ObjEffect_SetVertexXY(obj,(ii*6)+1,minx-16-kerning,-16*size);
			ObjEffect_SetVertexXY(obj,(ii*6)+2,minx+48*(size2)+kerning,-16*size);
			ObjEffect_SetVertexXY(obj,(ii*6)+3,minx-16-kerning,16);
			ObjEffect_SetVertexXY(obj,(ii*6)+4,minx+48*(size2)+kerning,16);
			ObjEffect_SetVertexXY(obj,(ii*6)+5,minx+48*(size2)+kerning,16);

			ObjEffect_SetVertexUV(obj,(ii*6)  ,char   ,1+32*type);
			ObjEffect_SetVertexUV(obj,(ii*6)+1,char   ,1+32*type);
			ObjEffect_SetVertexUV(obj,(ii*6)+2,char+32,1+32*type);
			ObjEffect_SetVertexUV(obj,(ii*6)+3,char   ,33+32*type);
			ObjEffect_SetVertexUV(obj,(ii*6)+4,char+32,33+32*type);
			ObjEffect_SetVertexUV(obj,(ii*6)+5,char+32,33+32*type);
		}else{
			ObjEffect_SetVertexXY(obj,(ii*6)  ,minx,-16*size);
			ObjEffect_SetVertexXY(obj,(ii*6)+1,minx,-16*size);
			ObjEffect_SetVertexXY(obj,(ii*6)+2,minx+32*(size2),-16*size);
			ObjEffect_SetVertexXY(obj,(ii*6)+3,minx,16);
			ObjEffect_SetVertexXY(obj,(ii*6)+4,minx+32*(size2),16);
			ObjEffect_SetVertexXY(obj,(ii*6)+5,minx+32*(size2),16);

			ObjEffect_SetVertexUV(obj,(ii*6)  ,char   ,1+32*type+32*symboltype);
			ObjEffect_SetVertexUV(obj,(ii*6)+1,char   ,1+32*type+32*symboltype);
			ObjEffect_SetVertexUV(obj,(ii*6)+2,char+32,1+32*type+32*symboltype);
			ObjEffect_SetVertexUV(obj,(ii*6)+3,char   ,33+32*type+32*symboltype);
			ObjEffect_SetVertexUV(obj,(ii*6)+4,char+32,33+32*type+32*symboltype);
			ObjEffect_SetVertexUV(obj,(ii*6)+5,char+32,33+32*type+32*symboltype);
		}	
	
		ObjEffect_SetVertexColor(obj,(ii*6)  ,alpha,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+1,alpha,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+2,alpha,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+3,alpha,ntc[3],ntc[4],ntc[5]);
		ObjEffect_SetVertexColor(obj,(ii*6)+4,alpha,ntc[3],ntc[4],ntc[5]);
		ObjEffect_SetVertexColor(obj,(ii*6)+5,alpha,ntc[3],ntc[4],ntc[5]);
	
		if(ghostrender[5]>-1){
			LetterAppear(font,Obj_GetX(obj)+cos(angle)*((minx+16)*xsize),Obj_GetY(obj)+sin(angle)*((minx+16)*xsize),char,alpha,xsize,ysize,angle,layer,ghostrender,ntc[0],ntc[1],ntc[2],ntc[3],ntc[4],ntc[5]);
		}
		
	}else{
		if(char==257*32){
			ScreenFlash;
		}
		if(char==258*32){
			if(ntc==ntc1){
				ntc=ntc2;
			}else{
				ntc=ntc1;
			}
		}
	}
	ii++;
	if(IsTextCleared(value)==false||ii2==0){
		if(GetKeyState(VK_SKIP)==KEY_FREE||GetCommonDataDefault("Skippable",0)==0){k+=delay;}else{k+=delay/6;}
		while(k>0){
			k--;
			yield;
		}
	}
	ii2++;
    }
    //loop(2){yield;}
    while(IsTextCleared(value)==false){yield;}
    ii=0; //counted characters
    k=0;
    let clearimmediatelysave=clearimmediately;
    if(delay>0){
	loop(strlen){
		ii2=0;
		loop(6){
			ObjEffect_SetVertexUV(obj,(ii*6)+ii2,0,0);
			ii2++;
		}
		if(align==-1){
			minx=(spacing[ii]*32)-(length(string)*32);
		}else if(align==1){
			minx=(spacing[ii]*32);
		}else{
			minx=(spacing[ii]*32)-(length(string)*16);
		}
		char=trunc(newstring[ii]);
		if((clearimmediatelysave==0||(clearimmediatelysave==0.5&&rand_int(0,1)==0))&&char<256*32){
			LetterAppear(font,Obj_GetX(obj)+cos(angle)*((minx+16)*xsize),Obj_GetY(obj)+sin(angle)*((minx+16)*xsize),char,alpha,xsize,ysize,angle,layer,[ALPHA,2,0,360,1,20],ntc[0],ntc[1],ntc[2],ntc[3],ntc[4],ntc[5]);
		}
		if(char<256*32){
			if(GetKeyState(VK_SKIP)==KEY_FREE||GetCommonDataDefault("Skippable",0)==0){k+=delay/2;}else{k+=delay/12;}
		}
		while(k>0){
			k--;
			yield;
		}
		ii++;
	}
    }
    Obj_Delete(obj);
}
task ScreenFlash{
	let obj=InitEffect(GetCenterX,GetCenterY,GPSD~"img\white.png",4,ADD,2);
	ObjEffect_SetXYRect(obj,-300,-300,300,300);
	ObjEffect_SetUVRect(obj,-300,-300,300,300);
	let alpha=50;
	loop(30){
		Obj_SetColor(obj,4,alpha,255,255,255);
		alpha-=50/30;
		yield;
	}
	Obj_Delete(obj);
}

function ToNumber(character){

//ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,!?()'"-~/{}


	let ret=0;
	alternative(character)
		case('A') {ret=0;} case('B') {ret=1;} case('C') {ret=2;} case('D') {ret=3;}
		case('E') {ret=4;} case('F') {ret=5;} case('G') {ret=6;} case('H') {ret=7;}
		case('I') {ret=8;} case('J') {ret=9;} case('K') {ret=10;} case('L') {ret=11;}
		case('M') {ret=12;} case('N') {ret=13;} case('O') {ret=14;} case('P') {ret=15;}
		case('Q') {ret=16;} case('R') {ret=17;} case('S') {ret=18;} case('T') {ret=19;}
		case('U') {ret=20;} case('V') {ret=21;} case('W') {ret=22;} case('X') {ret=23;}
		case('Y') {ret=24;} case('Z') {ret=25;}

		case('a') {ret=26;} case('b') {ret=27;} case('c') {ret=28;} case('d') {ret=29;}
		case('e') {ret=30;} case('f') {ret=31;} case('g') {ret=32;} case('h') {ret=33;}
		case('i') {ret=34;} case('j') {ret=35;} case('k') {ret=36;} case('l') {ret=37;}
		case('m') {ret=38;} case('n') {ret=39;} case('o') {ret=40;} case('p') {ret=41;}
		case('q') {ret=42;} case('r') {ret=43;} case('s') {ret=44;} case('t') {ret=45;}
		case('u') {ret=46;} case('v') {ret=47;} case('w') {ret=48;} case('x') {ret=49;}
		case('y') {ret=50;} case('z') {ret=51;}
		case('0') {ret=52;} case('1') {ret=53;} case('2') {ret=54;} case('3') {ret=55;} case('4') {ret=56;} 
		case('5') {ret=57;} case('6') {ret=58;} case('7') {ret=59;} case('8') {ret=60;} case('9') {ret=61;} 

		case('.') {ret=62;} case(',') {ret=63;} case('!') {ret=64;} case('?') {ret=65;} 
		case('(') {ret=66;} case(')') {ret=67;} case('\') {ret=68;} case(\') {ret=69;} 
		case('-') {ret=70;} case(':') {ret=71;} case('/') {ret=72;} case('[') {ret=73;}
		case(']') {ret=74;} case('{') {ret=75;} case('}') {ret=76;} case('|') {ret=77;} case('`') {ret=78;}

		case('@') {ret=79;}	//music note
		case('*') {ret=256;}	//add a pause in the line
		case('%') {ret=257;}	//add a flash of light
		case('#') {ret=258;}	//switch colors
		
		others {ret=-1;}

	
	return ret;
}

let letterappearskip=0;

task LetterAppear(font,x,y,left,alpha,scalex,scaley,rot,layer,options,r1,g1,b1,r2,g2,b2){

//options: [state,speed,angle1,angle2,spread,time]
    if(GetKeyState(VK_SKIP)!=KEY_FREE&&GetCommonDataDefault("Skippable",0)==1){
	letterappearskip=(letterappearskip+1)%3;
    }else{letterappearskip=0;}
	if(letterappearskip==0){
	let obj = Obj_Create(OBJ_EFFECT);
	let time=options[5];
	let st=options[4]/time;
	let totalpha=alpha;
	let ii=0;
	let totscaley=scaley;
	let frame=0;
	let k=0;
	let angle=rand(options[2],options[3]);

	Obj_SetPosition   (obj, x,y);
	Obj_SetSpeed	  (obj, 0);
	ObjEffect_SetAngle(obj, 0,0,rot);
	ObjEffect_SetTexture(obj,font);
	ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLESTRIP);
	ObjEffect_SetLayer(obj,layer);
	ObjEffect_CreateVertex(obj,4);
	ObjEffect_SetRenderState(obj,options[0]);
	ObjEffect_SetScale(obj,scalex,scaley);

	ObjEffect_SetVertexXY(obj,0,-16,-16);
	ObjEffect_SetVertexXY(obj,1, 16,-16);
	ObjEffect_SetVertexXY(obj,2,-16, 16);
	ObjEffect_SetVertexXY(obj,3, 16, 16);

	ObjEffect_SetVertexUV(obj,0,left+8 ,1);
	ObjEffect_SetVertexUV(obj,1,left+24,1);
	ObjEffect_SetVertexUV(obj,2,left+8 ,33);
	ObjEffect_SetVertexUV(obj,3,left+24,33);

	loop(time){
		ii=0;
		loop(2){
			ObjEffect_SetVertexColor(obj,ii  ,alpha,(r1+255)/2,(g1+255)/2,(b1+255)/2);
			ObjEffect_SetVertexColor(obj,ii+2,alpha,(r2+255)/2,(g2+255)/2,(b2+255)/2);
			ii++;
		}
		ObjEffect_SetScale(obj,scalex,scaley);
		Obj_SetPosition   (obj, x,y);

		x=x+cos(angle)*options[1];
		y=y+sin(angle)*options[1];

		alpha=(cos((90/time)*(frame)+90)+1)*totalpha;
		scalex+=st;
		frame++;


		if(GetKeyState(VK_SKIP)==KEY_FREE||GetCommonDataDefault("Skippable",0)==0){
			k+=1;
		}else{
			k+=1/6;
		}
		while(k>0){
			k--;
			yield;
		}

	}
	Obj_Delete(obj);
    }
}

let interrupttext=false;

sub InterruptNextLine{
	interrupttext=true;
}
function EventText(str,size,alpha,delay,yoffset,leading){
	EventText2(str,size,alpha,delay,yoffset,leading,0,0);
}
function EventTextWait(str,size,alpha,delay,yoffset,leading,wait){
	EventText2(str,size,alpha,delay,yoffset,leading,0,wait);
}
function EventTextV(str,size,alpha,delay,yoffset,leading){
	EventText2(str,size,alpha,delay,yoffset,leading,1,0);
}
function EventTextY(str,size,alpha,delay,yoffset,leading){
	EventText2(str,size,alpha,delay,yoffset,leading,2,0);
}
function EventTextO(str,size,alpha,delay,yoffset,leading){
	EventText2(str,size,alpha,delay,yoffset,leading,3,0);
}
function EventTextM(str,size,alpha,delay,yoffset,leading){
	EventText2(str,size,alpha,delay,yoffset,leading,4,0);
}
function EventText2(str,size,alpha,delay,yoffset,leading,effect,endwait){

	effectframe=0;

	let x=0;
	loop(length(str)-1){
		if((str[x]=='.'||str[x]==','||str[x]=='!'||str[x]=='?'||str[x]=='-')&&str[x+1]==' '){
			str=str[0..x+1]~"***"~str[x+1..length(str)];
			x+=3;
		}else if(str[x]=='.'){
			str=str[0..x+1]~"**"~str[x+1..length(str)];
			x+=2;
		}
		x++;
	}

	x=0;
	loop(length(str)){
		if(str[x]=='*'){
			str=str[0..x+1]~"***"~str[x+1..length(str)];	//for each * (pause), add more
			x+=3;
		}
		x++;
	}

	str=str~[' '];
	let len=length(str);
	x=0;
	let y=0;
	let loops=0;
	let lastspace=[len,len];
	let obj;
	let linebreak=false;
	loop(2){
		loops=(110/size)+1;
		linebreak=false;
		while(loops>0&&!linebreak){
			if(x<len){
				if(str[x]==' '){
					lastspace[y]=x;
				}
				if(str[x]=='^'){		//add a linebreak if it's ^
					lastspace[y]=x;
					linebreak=true;
				}
				if(str[x]=='*'||str[x]=='%'||str[x]=='#'){loops++;}	//if it's a special character, ignore it and loop again
			}
			x++;
			loops--;
		}
		x=lastspace[y];
		if(!linebreak){
			y++;
		}
	}

	let str1=str[0..lastspace[0]];
	obj=DrawTextBoldObj(1,str1,imgText,GetClipMinX+5,TextY+yoffset,0,size,size,7,1,alpha,delay);NextLine(size+(leading/(20/3)));
	if(effect>0){
		TextEffect(obj,length(str1),effect);
	}
	TextWait(letterlength(str1)*delay);

	let str2="";
	let str3="";
	if(lastspace[0]+1<lastspace[1]){
		str2=str[lastspace[0]+1..lastspace[1]];
		obj=DrawTextBoldObj(1,str2,imgText,GetClipMinX+5,TextY+yoffset,0,size,size,7,1,alpha,delay);
		TextEffect(obj,length(str2),effect);
		TextWait(letterlength(str2)*delay);
	}
	NextLine(size+(leading/(20/3)));
	if(lastspace[1]+1<len){
		str3=str[lastspace[1]+1..len];
		obj=DrawTextBoldObj(1,str3,imgText,GetClipMinX+5,TextY+yoffset,0,size,size,7,1,alpha,delay);
		TextEffect(obj,length(str3),effect);
		TextWait(letterlength(str3)*delay);
	}

	if(interrupttext==false){

		let deletearrow=false;
		let objarrow=InitEffect(GetCenterX,GetCenterY,imgBox,4,ALPHA,8);
		ObjEffect_SetXYRect(objarrow,-11,-11,11,11);
		ObjEffect_SetUVRect(objarrow,0,76,22,76+22);
		MoveArrow(objarrow);

		NextSpeaker(endwait);
		//return [obj,[length(str1),length(str2),length(str3)]];
		deletearrow=true;

		task MoveArrow(obj){
			let frame=0;
			let scale=0;
			loop(8){
				scale+=1/9;
				Obj_SetPosition(obj,GetClipMaxX-20,400+sin(frame)*2);
				ObjEffect_SetScale(obj,scale,1);
				Obj_SetColor(obj,4,255,255,210+cos(frame*3.6)*35,210+cos(frame*3.6)*35);
				frame+=5;
				yield;
			}
			ObjEffect_SetScale(obj,1,1);
			while(!deletearrow){
				Obj_SetPosition(obj,GetClipMaxX-20,400+sin(frame)*2);
				Obj_SetColor(obj,4,255,255,210+cos(frame*3.6)*35,210+cos(frame*3.6)*35);
				frame+=5;
				yield;
			}
			scale=1;
			loop(4){
				scale-=1/5;
				Obj_SetPosition(obj,GetClipMaxX-20,400+sin(frame)*2);
				ObjEffect_SetScale(obj,scale,1);
				Obj_SetColor(obj,4,255,255,210+cos(frame*3.6)*35,210+cos(frame*3.6)*35);
				frame+=5;
				yield;
			}
			Obj_Delete(obj);
		}
	}else{
		interrupttext=false;
	}
}
function letterlength(string){
	let k=0;
	let len=0;
	loop(length(string)){
		if(string[k]!=' '){len++;}
		k++;
	}
	return len;
}
function SetLine(offset){
	TextY=330+offset;
}
function NextLine(size){TextY+=(size*(20/3));}
function NextSpeaker(wait){WaitKey;yield;NextSpeaker2(wait);yield;effectframe++;}
task NextSpeaker2(wait){loop(wait){effectframe++;yield;}ClearTextHalf(1);TextY=330;}

function EventTextChoose(numstr,str,size,alpha,delay,yoffset,leading){
	let k=0;
	let maxlen=0;
	loop(numstr){
		DrawTextBoldObj(1,"  "~str[k],imgText,GetClipMinX+5,TextY+yoffset,0,size,size,7,1,alpha*0.75,delay);NextLine(size+(leading/(20/3)));
		if(length(str[k])>maxlen){maxlen=length(str[k]);}
		k++;
	}
	k=TextWait((maxlen+1)*delay);
	while(k<20){
		k++;
		if(GetKeyState(VK_SHOT)==KEY_PUSH){
			k=0;	//if the key is being mashed, don't automatically select the first choice
		}
		yield;
	}

	SetCommonData("DialogueChoice",1);
	k=0;
	let currentselection=-1;
	let selection=0;
	let obj=0;
	while(GetKeyState(VK_SHOT)!=KEY_PUSH){
		if(currentselection!=selection){
			if(currentselection>=0){
				SE("select");
			}
			ClearTextImmediately(0);
			yield;
			TextY=330;
			loop(selection){NextLine(size+(leading/(20/3)));}
			SetFontStyle(0,0,0,0,0,0);
			DrawTextBoldObj(0,"- "~str[selection],imgText,GetClipMinX+5,TextY+yoffset,0,size,size,7,1,alpha,0);
			obj=DrawTextBoldObj(0,"- "~str[selection],imgText,GetClipMinX+5,TextY+yoffset,0,size,size,7,1,alpha,0);
			SelectionFlash(obj,length(str[selection])+2);
			currentselection=selection;
		}
		if(GetKeyState(VK_UP)==KEY_PUSH){
			selection--;
			if(selection<0){selection=0;}
		}
		if(GetKeyState(VK_DOWN)==KEY_PUSH){
			selection++;
			if(selection>=numstr){selection=numstr-1;}
		}
		yield;
	}
	DeleteCommonData("DialogueChoice");
	SetCommonData("DialogueSelection",selection);
	SE("ok");
	ClearTextImmediately(0);
	NextSpeaker(0);
	//return [obj,[length(str1),length(str2),length(str3)]];

	task SelectionFlash(obj,len){
		let k=0;
		let k2=0;
		let frame=0;
		let alpha=0;
		while(!Obj_BeDeleted(obj)){
			ObjEffect_SetRenderState(obj,ADD);
			k=0;
			alpha=64+cos(frame)*64;
			loop(len){
				k2=0;
				loop(6){
					ObjEffect_SetVertexColor(obj,k*6+k2,alpha,255,255,255);
					k2++;
				}
				k++;
			}
			frame+=8;
			yield;
		}
	}
}


let effectframe=0;

task TextEffect(obj,length,effect){
	let k=0;
	let k2=0;
	if(effect==1){
		let coloroffset=0;
		let color=[0,0,0];
		while(!Obj_BeDeleted(obj)){
			k=0;
			coloroffset=0;
			loop(length){
				k2=0;
				//color=[Rainbow(0,effectframe*3+coloroffset)*127+128,Rainbow(1,effectframe*3+coloroffset)*127+128,Rainbow(2,effectframe*3+coloroffset)*127+128];
				color=[Rainbow(0,effectframe*3+coloroffset)*100+155,Rainbow(1,effectframe*3+coloroffset)*100+155,Rainbow(2,effectframe*3+coloroffset)*100+155];
				loop(6){
					ObjEffect_SetVertexColor(obj,k*6+k2,255,color[0],color[1],color[2]);
					k2++;
					coloroffset+=2;
				}
				k++;
			}
			yield;
		}
	}
	else if(effect==2){
		let coloroffset=rand(0,360);
		let color=[0,0,0];
		while(!Obj_BeDeleted(obj)){
			k=0;
			coloroffset=0;
			loop(length){
				k2=0;
				color=[230+sin(coloroffset+effectframe*-4)*25,100,200-sin(coloroffset+effectframe*-4)*55];
				loop(6){
					ObjEffect_SetVertexColor(obj,k*6+k2,255,color[0],color[1],color[2]);
					k2++;
					coloroffset+=5;
				}
				k++;
			}
			yield;
		}
	}
	else if(effect==3){
		let color=0;
		let lightness=0;
		while(!Obj_BeDeleted(obj)){
			k=0;
			loop(length){
				k2=0;
				color=rand(0,255);
				lightness=rand(0.6,1);
				loop(6){
					ObjEffect_SetVertexColor(obj,k*6+k2,255,255*lightness,255*lightness,color*lightness);
					k2++;
				}
				k++;
			}
			loop(3){if(!Obj_BeDeleted(obj)){yield;}}
		}
	}
	else if(effect==4){
		let color=[0,0,0];
		let frame=0;
		let startframe=rand(0,360);
		let mult=[rand(2,4),rand(2,4)];
		let flickerletter=-2;
		while(!Obj_BeDeleted(obj)){
			if(rand_int(0,6)==0){
				flickerletter=rand_int(0,length);
			}else{
				flickerletter=-2;
			}
			frame=startframe;
			k=0;
			loop(length){
				k2=0;
				loop(3){
					color=[lower(sin(-effectframe*mult[0]+frame)*120+255,255),200,lower(-sin(-effectframe*mult[1]+frame)*120+255,255)];
					if(absolute(flickerletter-k)>1){
						ObjEffect_SetVertexColor(obj,k*6+k2,255,color[0],color[1],color[2]);
					}else{
						ObjEffect_SetVertexColor(obj,k*6+k2,200,color[0],color[1],color[2]);
					}
					k2++;
				}
				loop(3){
					color=[lower(sin(-effectframe*mult[0]+frame)*255+255,255),0,lower(-sin(-effectframe*mult[1]+frame)*255+255,255)];
					if(absolute(flickerletter-k)>1){
						ObjEffect_SetVertexColor(obj,k*6+k2,255,color[0],color[1],color[2]);
					}else{
						ObjEffect_SetVertexColor(obj,k*6+k2,200,color[0],color[1],color[2]);
					}
					k2++;
				}
				frame+=15;
				k++;
			}
			loop(4){if(!Obj_BeDeleted(obj)){yield;}}
		}
	}
}




function ImageText(row,text,align,r,g,b){
	//creates a render target of the specified text

	let width=power2min(length(text)*16);

	CreateRenderTarget(text,width,32);
	let prev=SetRenderTarget(text);
	ClearRenderTarget(text);

	SetTexture(imgText);
	SetGraphicAngle(0,0,0);
	SetGraphicScale(1,1);
	SetAlpha(255);
	SetColor(r,g,b);
	let i=0;
	let len=length(text);
	let char;
	let offset=(width/2-len*8)*(-align+1);
	let color2=newtextcolor2;
	let colorchanged=false;
	loop(len){
		if(text[i]!=' '&&text[i]!='#'){
			char=ToNumber(text[i]);
			SetGraphicRect(char*32,row*32,char*32+32,row*32+32);
			DrawGraphic(i*16+8+offset,16);
		}
		if(text[i]=='#'){
			if(colorchanged){
				SetColor(r,g,b);
				colorchanged=false;
			}else{
				SetColor(color2[0],color2[1],color2[2]);
				colorchanged=true;
			}
		}
		i++;
	}
	SetRenderTarget(prev);
	SetColor(255,255,255);
	return text;
}

function ObjText(row,text,align,alpha,r,g,b,r2,g2,b2,appeartime){
	let texture=ImageText(row,text,align,255,255,255);
	let obj=InitEffect(0,0,texture,4,ALPHA,3);
	let width=power2min(length(text)*16);
	let offset=(width/2)*(align-1);
	ObjEffect_SetVertexColor(obj,0,alpha,r,g,b);
	ObjEffect_SetVertexColor(obj,1,alpha,r,g,b);
	ObjEffect_SetVertexColor(obj,2,alpha,r2,g2,b2);
	ObjEffect_SetVertexColor(obj,3,alpha,r2,g2,b2);
	ObjTextAppear(obj,length(text),width,offset,appeartime);
	return obj;
}
task ObjTextAppear(obj,len,width,offset,appeartime){
	if(appeartime==0){
		ObjEffect_SetXYRect(obj,offset,-16,width+offset,16);
		ObjEffect_SetUVRect(obj,0,0,width,32);
	}else{
		let currentwidth=0;
		let widthadd=1/appeartime;
		loop(appeartime){
			currentwidth+=widthadd;
			ObjEffect_SetXYRect(obj,offset,-16,offset+width*currentwidth,16);
			ObjEffect_SetUVRect(obj,0,0,width*currentwidth,32);
			yield;
		}
	}
}





task InitEvent{
    SetCommonData("Skippable",1);
    SetCommonData("ForbidShot",1);
    ForbidShot(true);
    ForbidBomb(true);
    LoadGraphic(imgBox);
    let ii=0;
    let ii2=0;
    loop(4){
	EventPosO[ii]=Obj_Create(OBJ_EFFECT);
	ObjEffect_SetPrimitiveType(EventPosO[ii],PRIMITIVE_TRIANGLEFAN);
	ObjEffect_SetScale(EventPosO[ii],1,1);
	ObjEffect_SetLayer(EventPosO[ii],5);
	ObjEffect_CreateVertex(EventPosO[ii],4);
	ObjEffect_SetRenderState(EventPosO[ii],ALPHA);
	ii++;
    }
    ii=0;

    objbox=InitEffect(GetClipMinX,330,imgBox,4,ALPHA,6);
    ObjEffect_SetUVRect(objbox,0,0,512,75);
    ObjEffect_SetXYRect(objbox,0-64,0,384+64,75);

    DrawEventPositions;
    loop(20){
	ii2=0;
	loop(4){
		ObjEffect_SetVertexColor(objbox,ii2,ii,255,255,255);
		ii2++;
	}
	ii+=11;
	Obj_SetPosition(objbox,GetClipMinX+ScreenShakeX,330+ScreenShakeY);
	yield;
    }
    while(!Obj_BeDeleted(objbox)){
	Obj_SetPosition(objbox,GetClipMinX+ScreenShakeX,330+ScreenShakeY);

	yield;
    }
}
task EndEvent(endforbidshot){
    SetActive(-1,-1,-1,-1);

    let ii=220;
    let ii2=0;
    loop(20){
	ii2=0;
	loop(4){
		ObjEffect_SetVertexColor(objbox,ii2,ii,255,255,255);
		ii2++;
	}
	ii-=11;
	yield;
    }
    Obj_Delete(objbox);

    ii2=0;
    loop(4){
	Obj_Delete(EventPosO[ii2]);
	ii2++;
    }
    DeleteCommonData("Skippable");
    if(endforbidshot){
	ForbidShot(false);
	ForbidBomb(false);
	DeleteCommonData("ForbidShot");
    }else{
//	ForbidShot(true);
//	ForbidBomb(true);
//	SetCommonData("ForbidShot",1);
    }
}

task DrawEventPositions{
//runs once during initialization
	let i=0;
	while(!Obj_BeDeleted(objbox)){
		i=0;
		loop(4){
			DrawEvent(i);
			i++;
		}
		yield;
	}
}

let topchar=[0,0];

function SetEventCharacter(pos){
//runs once when the character is switched

    let left=EventPosL[pos];
    let top=0;
    let right=EventPosR[pos];
    let bottom=EventPosB[pos];
    let width=right-left;

    ObjEffect_SetTexture(EventPosO[pos],EventPosC[pos]);
    ObjEffect_SetUVRect(EventPosO[pos],left,top,right,bottom);
    if(pos<2){
	ObjEffect_SetXYRect(EventPosO[pos],EventPosX[pos],-bottom,width+EventPosX[pos],0);
    }else{
	ObjEffect_SetXYRect(EventPosO[pos],-width-EventPosX[pos],-bottom,-EventPosX[pos],0);
    }

    if(pos==0){
	topchar[0]=0;
	SetLayers(0);
    }else if(pos==1){
	topchar[0]=1;
	SetLayers(0);
    }else if(pos==2){
	topchar[1]=0;
	SetLayers(1);
    }else{
	topchar[1]=1;
	SetLayers(1);
    }

}

function SetLayers(currentside){
	ObjEffect_SetLayer(EventPosO[0+currentside*2]    ,5+(1-topchar[0]));
	ObjEffect_SetLayer(EventPosO[1+currentside*2]    ,5+topchar[0]);
	ObjEffect_SetLayer(EventPosO[0+(1-currentside)*2],4+(1-topchar[1]));
	ObjEffect_SetLayer(EventPosO[1+(1-currentside)*2],4+topchar[1]);
}

function DrawEvent(pos){
//runs once each frame per position
	let eventpositions=[GetClipMinX-50,GetClipMinX+30,GetClipMaxX-30,GetClipMaxX+50];
	let direction=[1,1,-1,-1];

	EventPosP[pos]=SlowChange(EventPosP[pos],EventPosA[pos],0.15);

	let ii=0;
	let color=PercentageHigher(pos)*80+175;
	loop(4){
		//ObjEffect_SetVertexColor(EventPosO[pos], ii,MovePercentage(pos)*255,255,255,255);
		ObjEffect_SetVertexColor(EventPosO[pos], ii,PercentageLower(pos)*255,color,color,color);
		ii++;
	}
	Obj_SetPosition(EventPosO[pos],round((eventpositions[pos]-(1-EventPosP[pos])*20*direction[pos])+ScreenShakeX),round(GetClipMaxY-80+(1-EventPosP[pos])*5+ScreenShakeY));
}
function SetActive(a,b,c,d){
	EventPosA=[a,b,c,d];
}
function SetActiveNoDelay(a,b,c,d){
	EventPosA=[a,b,c,d];
	EventPosP=[a,b,c,d];
}
function PercentageLower(pos){
	return lower((EventPosP[pos]+1),1);
}
function PercentageHigher(pos){
	return upper(0,EventPosP[pos]);
}
function SlowChange(original,target,speed){
	if(absolute(original-target)<=speed){return target;}
	else if(original<target){return original+speed;}
	else{return original-speed;}
}



function DisplayCharName(name,title,kana){
	let width=1;
	let kwidth=1;
	let yoffset=0;
	if(length(name)>10){
		width=10/length(name);
		yoffset=5;
	}
	if(length(kana)>16){
		kwidth=16/length(kana);
	}
	if(length(kana)<=8){
		kwidth=1.2;
	}
	DisplayCharName2(kana,1,  1.2*kwidth,1.6*kwidth, -13,GetClipMaxX-length(name)*32*0.4*width-80,290	,[255,255,255,150,205,205]);
	DisplayCharName2(title,0, 0.3,0.7, 2,GetClipMaxX-15,312+yoffset						,[255,255,255,70,70,150]);
	DisplayCharName2(name,0,  0.5*width,0.8, -5,GetClipMaxX-30,285						,[255,255,255,200,255,255]);
}
function DisplayCharName2(string,type,xsize,ysize,angle,x,y,ntc){
	DisplayCharName3(string,type,xsize,ysize,angle,x,y,ADD,ntc);
	DisplayCharName3(string,type,xsize,ysize,angle,x,y,ALPHA,ntc);
}
task DisplayCharName3(string,type,xsize,ysize,angle,x,y,renderstate,ntc){

    let obj = Obj_Create(OBJ_EFFECT);
    let ii=0;
    let ii2=0;
    let k=0;
    let minx=0;
    let miny=0;
    let string2=[];
    if(type==1){
	loop(length(string)/2){
		ii2=ToKana(string[ii],string[ii+1]);
		string2=string2~[ii2];
		ii+=2;
	}
    }else{
	loop(length(string)){
		string2=string2~[ToNumber(string[ii])*32];
		ii++;
	}
    }

    Obj_SetPosition(obj,x,y);
    Obj_SetSpeed      (obj, 0);
    ObjEffect_SetAngle(obj, 0,0,angle);
    ObjEffect_SetTexture(obj,imgText);
    ObjEffect_SetPrimitiveType(obj,PRIMITIVE_TRIANGLESTRIP);
    ObjEffect_SetLayer(obj,7);
    ObjEffect_CreateVertex(obj,length(string)*6);
    ObjEffect_SetRenderState(obj,renderstate);
    ObjEffect_SetScale(obj,xsize,ysize);

    let char=0;
    let size=1;
    let size2=1;
    let xoffsetminus=0;
    let symboltype=0;
    ii2=0;	//total characters
    ii=0;	//counted characters
    loop(length(string2)){
	if(type==0){
		char=string2[ii2];
	}else{
		char=string2[ii2];
		size=1;
		size2=1;
		symboltype=0;
		if((string2[ii2]*100%10)>0){//if hundredths digit is not 0
			symboltype=(string2[ii2]*100)%10;
			string2[ii2]=(trunc(string2[ii2]*10))/10;	//remove hundredths digit
		}
		if(string2[ii2]!=trunc(string2[ii2])){
			size=0.6;
			size2=0.9;
			xoffsetminus+=2;
		}
		char=trunc(char)*32;
	}
	if(char<(256*32)){
		if(type==0){
			minx=(ii*32)-(length(string)*32);
		}else{
			minx=(ii*24)-xoffsetminus;
		}
//		}else if(align==1){
//			minx=(ii*32);
//		}else{
//			minx=(ii*32)-(length(string)*16);
//		}
		ObjEffect_SetVertexXY(obj,(ii*6)  ,minx,-16*size);
		ObjEffect_SetVertexXY(obj,(ii*6)+1,minx,-16*size);
		ObjEffect_SetVertexXY(obj,(ii*6)+2,minx+32*(size2),-16*size);
		ObjEffect_SetVertexXY(obj,(ii*6)+3,minx,16);
		ObjEffect_SetVertexXY(obj,(ii*6)+4,minx+32*(size2),16);
		ObjEffect_SetVertexXY(obj,(ii*6)+5,minx+32*(size2),16);

		if(char<0){
			ObjEffect_SetVertexUV(obj,(ii*6)  ,0,0);
			ObjEffect_SetVertexUV(obj,(ii*6)+1,0,0);
			ObjEffect_SetVertexUV(obj,(ii*6)+2,0,0);
			ObjEffect_SetVertexUV(obj,(ii*6)+3,0,0);
			ObjEffect_SetVertexUV(obj,(ii*6)+4,0,0);
			ObjEffect_SetVertexUV(obj,(ii*6)+5,0,0);			
		}		
		else if(type==0){
			ObjEffect_SetVertexUV(obj,(ii*6)  ,char+8 ,1);
			ObjEffect_SetVertexUV(obj,(ii*6)+1,char+8 ,1);
			ObjEffect_SetVertexUV(obj,(ii*6)+2,char+24,1);
			ObjEffect_SetVertexUV(obj,(ii*6)+3,char+8 ,33);
			ObjEffect_SetVertexUV(obj,(ii*6)+4,char+24,33);
			ObjEffect_SetVertexUV(obj,(ii*6)+5,char+24,33);
		}else{
			ObjEffect_SetVertexUV(obj,(ii*6)  ,char   ,33+32*type+32*symboltype);
			ObjEffect_SetVertexUV(obj,(ii*6)+1,char   ,33+32*type+32*symboltype);
			ObjEffect_SetVertexUV(obj,(ii*6)+2,char+32,33+32*type+32*symboltype);
			ObjEffect_SetVertexUV(obj,(ii*6)+3,char   ,65+32*type+32*symboltype);
			ObjEffect_SetVertexUV(obj,(ii*6)+4,char+32,65+32*type+32*symboltype);
			ObjEffect_SetVertexUV(obj,(ii*6)+5,char+32,65+32*type+32*symboltype);
		}	
		ObjEffect_SetVertexColor(obj,(ii*6)  ,0,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+1,0,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+2,0,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+3,0,ntc[3],ntc[4],ntc[5]);
		ObjEffect_SetVertexColor(obj,(ii*6)+4,0,ntc[3],ntc[4],ntc[5]);
		ObjEffect_SetVertexColor(obj,(ii*6)+5,0,ntc[3],ntc[4],ntc[5]);

		ii++;
	}
	ii2++;
	xoffsetminus+=(1-size2)*24;
    }
    let opacityadd=255/30;
    let opacity=0;
    loop(30){
	opacity+=opacityadd;
	ii=0;
	loop(length(string2)*6){
		ObjEffect_SetVertexColor(obj,(ii*6)  ,opacity,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+1,opacity,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+2,opacity,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+3,opacity,ntc[3],ntc[4],ntc[5]);
		ObjEffect_SetVertexColor(obj,(ii*6)+4,opacity,ntc[3],ntc[4],ntc[5]);
		ObjEffect_SetVertexColor(obj,(ii*6)+5,opacity,ntc[3],ntc[4],ntc[5]);
		ii++;
	}
	yield;
	if(GetKeyState(VK_SKIP)==KEY_FREE){
		yield;
	}
    }
    loop(60){
	yield;
	if(GetKeyState(VK_SKIP)==KEY_FREE){
		yield;
		yield;
	}
    }
    loop(30){
	opacity-=opacityadd;
	ii=0;
	loop(length(string2)*6){
		ObjEffect_SetVertexColor(obj,(ii*6)  ,opacity,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+1,opacity,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+2,opacity,ntc[0],ntc[1],ntc[2]);
		ObjEffect_SetVertexColor(obj,(ii*6)+3,opacity,ntc[3],ntc[4],ntc[5]);
		ObjEffect_SetVertexColor(obj,(ii*6)+4,opacity,ntc[3],ntc[4],ntc[5]);
		ObjEffect_SetVertexColor(obj,(ii*6)+5,opacity,ntc[3],ntc[4],ntc[5]);
		ii++;
	}
	yield;
	if(GetKeyState(VK_SKIP)==KEY_FREE){
		yield;
	}
    }

    Obj_Delete(obj);
}
function ToKana(char1,char2){
//takes two letters as input, returns its hiragana/katakana equivalent
//Uppercase is katakana, lowercase is hiragana
//numbers (00,01, etc) give kanji

	let ret=-1;

	if(char1==' '&&char2==' '){
		return -1.5;
	}

	let oldchar=char2;
	char1=ToLower(char1);
	char2=ToLower(char2);
	if(char2==oldchar){//if it was lowercase
		ret+=0.01;
	}
	if(char1=='.'&&char2!='t'){
		ret+=0.5;	//small letter
		char1=' ';
	}
	let string=[char1,char2];
	if(string=="||"){
		return 73.5;	// middle dot
	}
	if(string=="--"){
		return 71;	// dash (I don't know why it doesn't work normally)
	}
	if(string==".t"){
		ret+=18.5;
		return ret;	//small tsu
	}else if(string==",a"){
		ret+=36.5;
		return ret;	//small ya
	}else if(string==",u"){
		ret+=37.5;
		return ret;	//small yu
	}else if(string==",o"){
		ret+=38.5;
		return ret;	//small yo
	}
	let k=0;
	let found=false;
	while(k<73&&found==false){
		if(string==kanaarray[k]){
			ret+=k+1;
			found=true;
		}
		k++;
	}
	k=0;
	while(k<16){
		if(string==kanjiarray[k]){
			return k+0.02;
		}
		k++;
	}
	return ret;
}
let kanaarray=[
" a"," i"," u"," e"," o",
"ka","ki","ku","ke","ko",
"sa","si","su","se","so",
"ta","ti","tu","te","to",
"na","ni","nu","ne","no",
"ha","hi","fu","he","ho",
"ma","mi","mu","me","mo",
"ya","yu","yo",
"ra","ri","ru","re","ro",
"wa","wo",
"ga","gi","gu","ge","go",
"za","zi","zu","ze","zo",
"da","di","du","de","do",
"ba","bi","bu","be","bo",
"pa","pi","pu","pe","po",
" n","--"," v"];

let kanjiarray=[
"00","01","02","03","04","05","06","07","08","09","10","11","12","13","14","15"
];

function ToUpper(char){
	let k=0;
	loop(26){
		if(lowercasearray[k]==char){
			return uppercasearray[k];
		}
		k++;
	}
	return char;
}
function ToLower(char){
	let k=0;
	loop(26){
		if(uppercasearray[k]==char){
			return lowercasearray[k];
		}
		k++;
	}
	return char;
}
let lowercasearray=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'];
let uppercasearray=['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'];

function SetCharacter(char,expression,pos){
	let BoundingBox=[0,0,0,0]; //L,R,B,offset
	if(char=="Generic"){
		SetFontStyle(0,0,0,0,0,0);
		SetFontColorNew(255,255,255,200,200,200);
		SetFontColorEmphasis(255,255,255,255,0,0);
	}
	if(char=="Lymia"){
		SetFontStyle(1,0,0,0,4,10);
		//SetFontColorNew(255,100,255,196,255,255);
		SetFontColorNew(255,255,255,255,100,255);
		SetFontColorEmphasis(255,255,255,255,200,255);
		EventPosC[pos]=GPSD~"img\dialoguelymia.png";
		if(ExPlayer){EventPosC[pos]=GPSD~"img\dialoguelymia2.png";}
		BoundingBox=[256*expression,256*(expression+1),256,15];
	}
	if(char=="Raibys"){
		SetFontStyle(0,-2,-15,15,2,15);
		SetFontColorNew(255,255,255,0,255,0);
		SetFontColorEmphasis(255,255,255,190,255,190);
		EventPosC[pos]=GPSD~"img\dialogueraibys.png";
		if(ExPlayer){EventPosC[pos]=GPSD~"img\dialogueraibys2.png";}
		BoundingBox=[204*expression,204*(expression+1)-1,324,0];
	}
	if(char=="Nhimor"){
		SetFontStyle(1,0.5,0,360,4,20);
		SetFontColorNew(70,255,255,150,255,150);
		SetFontColorEmphasis(255,255,255,100,100,255);
		EventPosC[pos]=GPSD~"img\dialoguenhimor.png";
		BoundingBox=[170*expression,170*(expression+1),256,26];
		SetCommonData("NhimorTargetColor",expression);
	}
	if(char=="Meteo"){
		SetFontStyle(2,2,-15,15,2,15);
		SetFontColorNew(255,255,255,255,0,255);
		EventPosC[pos]=GPSD~"img\dialoguemeteo.png";
		BoundingBox=[240*expression,240*(expression+1),340,0];
	}
	if(char=="Ender"){
		SetFontStyle(2,1,60,310,30,30);
		SetFontColorNew(255,128,64,128,128,196);
		EventPosC[pos]=GPSD~"img\dialogueender.png";
		BoundingBox=[256*expression,256*(expression+1),320,0];
	}
	if(char=="Empegh"){
		SetFontStyle(2,2,0,360,5,60);
		SetFontColorNew(255,255,64,196,128,128);
		EventPosC[pos]=GPSD~"img\dialogueempegh.png";
		BoundingBox=[170*expression,170*(expression+1),300,40];
	}
	if(char=="Overload"){
		SetFontStyle(2,0.5,0,360,3,20);
		SetFontColorNew(255,255,200,100,100,0);
		EventPosC[pos]=GPSD~"img\dialogueoverload.png";
		BoundingBox=[256*expression,256*(expression+1),512,20];
	}
	if(char=="Yumemi"){
		SetFontStyle(1,1.5,0,360,2,10);
		SetFontColorNew(255,196,196,255,128,0);
		SetFontColorEmphasis(255,196,196,255,0,0);
		EventPosC[pos]=GPSD~"img\dialogueyumemi.png";
		BoundingBox=[256*expression,256*(expression+1),375,0];
	}
	if(char=="Yukari"){
		SetFontStyle(1,0.5,0,360,2,60);
		SetFontColorNew(255*0.6,100*0.6,255*0.6,255*0.6,100*0.6,255*0.6);
		EventPosC[pos]=GPSD~"img\dialogueyukari.png";
		BoundingBox=[330*expression,330*(expression+1),335,0];
	}
	if(char=="Countdown"){
		SetFontStyle(2,0.1,0,360,3,100);
		SetFontColorNew(255,196,128,64,64,64);
	}
	if(char=="Arc"){
		SetFontStyle(2,0.7,-10,10,15,80);
		SetFontColorNew(255,255,128,128,128,128);
	}
	if(char=="Inferno"){
		SetFontStyle(2,0.3,0,-180,7,140);
		SetFontColorNew(255,0,0,200,200,200);
	}
	if(char=="Vapor"){
		SetFontStyle(1,0.5,0,360,15,30);
		SetFontColorNew(255,255,255,255,255,255);
	}

	EventPosL[pos]=BoundingBox[0];
	EventPosR[pos]=BoundingBox[1];
	EventPosB[pos]=BoundingBox[2];
	EventPosX[pos]=BoundingBox[3];

	SetEventCharacter(pos);

}
function LoadDialoguePics(pics){
	let i=0;
	loop(length(pics)){
		LoadGraphic(GPSD~"img\dialogue"~pics[i]~".png");
		i++;
	}
}
function DeleteDialoguePics(pics){
	let i=0;
	loop(length(pics)){
		DeleteGraphic(GPSD~"img\dialogue"~pics[i]~".png");
		i++;
	}
}
task Dialogue(stage,num){
	while(OnPlayerMissed){yield;}
	if(IsAWCPlayer&&GetOption(3)==0&&GetPlayer<6){
		SetCommonData("DialogueSelection",-1);
		ForbidShot2(true);
		SetCommonData("Dialogue",1);
		SetCommonData("EventStep",0);
		InitEvent;
		loop(15){yield;}
		if(GetPlayer==0){
			LymiaEvent(stage,num);
		}
		else if(GetPlayer==1){
			RaibysEvent(stage,num);
		}
		else if(GetPlayer==2){
			NhimorEvent(stage,num);
		}
		loop(20){yield;}
		let lastevent=[0,1,2,2];
		if(lastevent[stage]==num){	//don't un-forbid bomb if the score card is going to pop up
			EndEvent(false);
		}else{
			EndEvent(true);
			ForbidShot2(false);
		}
		DeleteCommonData("Dialogue");
		DeleteCommonData("EventStep");
		DeleteCommonData("NhimorTargetColor");
	}
}
task TutDialogue(num,trynum,endforbidshot){
	SetCommonData("DialogueSelection",-1);
	ForbidShot2(true);
	SetCommonData("Dialogue",1);
	SetCommonData("EventStep",0);
	InitEvent;
	loop(15){yield;}
	TutorialEvent(num,trynum);
	loop(20){yield;}
	EndEvent(false);
	if(endforbidshot){
		ForbidShot2(false);
		ForbidBomb(true);
	}
	DeleteCommonData("Dialogue");
	DeleteCommonData("EventStep");
	DeleteCommonData("NhimorTargetColor");
}
function GetDialogueSelection{
	return GetCommonDataDefault("DialogueSelection",-1);
}
function EventActive{
	return GetCommonDataDefault("Dialogue",0)==1;
}
function EventStep{
	return GetCommonDataDefault("EventStep",0);
}
task SetEventStep(num){
	SetCommonData("EventStep",num);
	yield;
	SetCommonData("EventStep",0);
}
