let CSD = GetCurrentScriptDirectory;

let texFloor = CSD ~ "images/stg5bg.png";

let bSpell = false;

LoadCommonDataAreaA1("Stage part");
let stagepart = GetAreaCommonData("Stage part", "Stagepart", 0);
LoadCommonDataAreaA2("Boss Spell", "./CDarea.dnh");

let mask;

let obj4;

@Initialize{
	ObjRender_SetY(text, 100);
	mask = ObjMask_Create("example_mask", 24, 26); // applies to layers 24~26
	ObjRender_SetAlpha(mask, 0);
	let canvas = ObjPrim_Create(OBJ_SPRITE_2D);
	Del(mask);
	ObjPrim_SetTexture(canvas, GetCurrentScriptDirectory() ~ "white.png"); // white pixel
	ObjSprite2D_SetSourceRect(canvas, 0, 0, 1024, 512); // 1024x512 is render target size
	ObjSprite2D_SetDestRect(canvas, 0, 0, 1024, 512);
	ObjMask_AddSource(mask, canvas);
	Shader;
	renderStage;
	scrollStage;
	TSpellBackground;
	TSpellBackgroundBoss;
}

@MainLoop{
	stagepart = GetAreaCommonData("Stage part", "Stagepart", 0);
    if(GetAreaCommonData("Boss Spell", "Active", false) == true){
        bSpell = true;
    }else{
        bSpell = false;
    }
    ObjText_SetText(text, bSpell);
 	yield;
}

@Finalize{

}

task Del(obj){
	loop{
		if(stagepart == 1){
			Obj_Delete(obj);
			break;
		}
		yield;
	}
}

task renderStage{
	SetFogEnable(true);
	SetFogParam(512, 1536, 195, 29, 204);

	let Y = round(32768^(1/2));
	let addCount = 11; //11
	let l = 0;
	let r = addCount;
	let y = 39;
	let z = 49;
	let y1 = -(2*Y) + 8;
	let z1 = -(2*Y) - 8;
	let y2 = -(3*Y) + 8;
	let z2 = -(2*Y) - 8;
	let n = 0;
	loop(8){
		if(n == 0){
			n ++;
			let obj = Shine(-15,y1 + 60,z1,255);
			Alpha(obj);
			obj = Shine(271,y1 + 60,z1,255);
			Alpha(obj);
			obj = Shine1(-15,y1 + 60,z1,255);
			Alpha(obj);
			obj = Shine1(271,y1 + 60,z1,255);
			Alpha(obj);
		}

		makeFloor5(-160,y1 - 100,z1 + 100,255); //all of the Floor objects have 22 on render priority
		makeFloor5(417,y1 - 100,z1 + 100,255);
		makeFloor5(-480,y1 - 100,z1 + 100,255);
		makeFloor5(737,y1 - 100,z1 + 100,255);
		makeFloor5(-800,y1 - 100,z1 + 100,255);
		makeFloor5(1057,y1 - 100,z1 + 100,255);

		makeFloor1(-15,y1,z1,255);
		makeFloor2(0,y2,z2,255);
		makeFloor1(271,y1,z1,255);
		makeFloor2(256,y2,z2,255);
		y1 += Y;
		z1 += Y;
		y2 += Y;
		z2 += Y;
		n ++;
		if(n >= 3){
			n = 0;
		}
	}
	loop(70){
		makeFloor3(128,y,z,255,l,256,r,512);
		r += addCount;
		l += addCount;
		if(r > 256 - addCount){
			r = addCount;
			l = 0;
		}
		y += addCount/2;
		z += addCount/2;
		makeFloor4(128,y,z,255,l,256,r,512);
		r += addCount;
		l += addCount;
		y += addCount/2;
		z += addCount/2;
		if(r > 256 - addCount){
			r = addCount;
			l = 0;
		}
	}

	task Alpha(obj){
		let alp = 255;
		loop(3600){
			alp -= 255/3600;
			ObjRender_SetAlpha(obj, alp);
			yield;
		}
	}
}

task scrollStage{
	let Y = 32768^(1/2);
	let text = ObjText_Create;
	let i = 0;
	let f = 0;
	let scroll = 0;

	SetCameraPerspectiveClip(16, 4096);

	SetCameraAzimuthAngle(-45);//-45
	SetCameraElevationAngle(45);
	SetCameraRadius(400);   //400

	SetCameraFocusX(96);//96
	SetCameraFocusY(250);
	SetCameraFocusZ(0);

	SetCameraYaw(0);
	SetCameraPitch(-20);
	SetCameraRoll(0);

	let dark = ObjPrim_Create(OBJ_SPRITE_2D);
	ObjPrim_SetTexture(dark, GetCurrentScriptDirectory() ~ "images/Black.png");
	ObjSprite2D_SetSourceRect(dark, 0, 0, 512, 512);
	ObjRender_SetPosition(dark, GetCenterX, GetCenterY, 0);
	ObjSprite2D_SetDestCenter(dark);
	ObjRender_SetBlendType(dark, BLEND_ALPHA);
	Obj_SetRenderPriorityI(dark, 25);
	ObjRender_SetAlpha(dark, 200);
	let alp = 200;

	loop(3600){
		alp -= 200/3600;
		ObjRender_SetAlpha(dark, alp);
		scroll += Y/128;
		SetCameraFocusZ(0+scroll);
		SetCameraFocusY(250+scroll);//250
		if(scroll >= 362){
			scroll = 0;
		}
		yield;
	}
	wait(60);
	let elev = 45;
	let az = -45;
	let X = 96;
	loop(240){
		X += 32/240;
		az -= 45/240;
		elev -= 10/240;
		SetCameraFocusX(X);
		SetCameraAzimuthAngle(az);
		SetCameraElevationAngle(elev);
		yield;
	}
	TDBG;
}

task Visible(obj){
	wait(3901);
	Obj_Delete(obj);
}

task TSpellBackground{
	let count = 0;
	loop{
		if(bSpell == true && stagepart == 0 && count == 0){
			count ++;
			Init;
		}else if(bSpell == false){
			count = 0;
		}
		yield;
	}

	task Init{
	    let alpha = 255;

	    let obj = ObjPrim_Create(OBJ_SPRITE_2D);
	    ObjPrim_SetTexture(obj, GetCurrentScriptDirectory ~ "images/Youmu/cdbg0.png");
	    ObjSprite2D_SetSourceRect(obj, 0, 0, 256, 256);
	    ObjSprite2D_SetDestRect(obj, -192, -224, 192, 224);
	    ObjRender_SetPosition(obj, GetStgFrameWidth/2, GetStgFrameHeight/2, 0);
	    Obj_SetRenderPriorityI(obj, 20);
	    ObjRender_SetAlpha(obj, alpha);
	    ObjRender_SetBlendType(obj, BLEND_ALPHA);

	    let obj1 = ObjPrim_Create(OBJ_SPRITE_2D);
	    ObjPrim_SetTexture(obj1, GetCurrentScriptDirectory ~ "images/Youmu/cdbg1.png");
	    ObjSprite2D_SetSourceRect(obj1, 0, 0, 256, 256);
	    ObjRender_SetScaleXYZ(obj1, 2.5, 2.5, 2.5);
	    ObjSprite2D_SetDestCenter(obj1);
	    Obj_SetRenderPriorityI(obj1, 20);
	    ObjSprite2D_SetDestCenter(obj1);
	    ObjRender_SetPosition(obj1, GetStgFrameWidth/2, GetStgFrameHeight/2, 0);
	    ObjRender_SetAlpha(obj1, alpha);
	    ObjRender_SetBlendType(obj1, BLEND_ALPHA);

	    let angleT = 0;
	    while(!Obj_IsDeleted(obj)){
	        angleT += 0.3;
	        if(bSpell == false){
	        	loop(60){
		        	alpha -= 255/60;
		        	ObjRender_SetAlpha(obj, alpha);
		        	ObjRender_SetAlpha(obj1, alpha);
		        	yield;
	        	}
	        	Obj_Delete(obj);
	        	Obj_Delete(obj1);
	        }
	    	ObjRender_SetAngleZ(obj1, angleT);
	    	yield;
	    }
	}
}

task TSpellBackgroundBoss{
	let count1 = 0;
	loop{
		if(bSpell == true && stagepart == 1 && count1 == 0){
			count1 ++;
			Init;
		}else if(bSpell == false){
			count1 = 0;
		}
		yield;
	}

	task Init{
	    let alpha = 0;

	    let obj1 = ObjPrim_Create(OBJ_SPRITE_2D);
	    ObjPrim_SetTexture(obj1, GetCurrentScriptDirectory ~ "images/Yuyuko/cardbg1.png");
	    ObjSprite2D_SetSourceRect(obj1, 0, -256, 256, 512);
	    ObjRender_SetScaleXYZ(obj1, 1.5, 1.5, 1.5);
	    ObjSprite2D_SetDestCenter(obj1);
	    Obj_SetRenderPriorityI(obj1, 27);
	    ObjSprite2D_SetDestCenter(obj1);
	    ObjRender_SetPosition(obj1, GetStgFrameWidth/2, GetStgFrameHeight/2, 0);
	    ObjRender_SetAlpha(obj1, alpha);
	    ObjRender_SetBlendType(obj1, BLEND_ADD_ARGB);

	    let obj = ObjPrim_Create(OBJ_SPRITE_2D);
	    ObjPrim_SetTexture(obj, GetCurrentScriptDirectory ~ "images/Yuyuko/cardbg0.png");
	    ObjSprite2D_SetSourceRect(obj, 0, 0, 384, 448);
	    ObjSprite2D_SetDestCenter(obj);
	    Obj_SetRenderPriorityI(obj, 27);
	    ObjRender_SetPosition(obj, GetStgFrameWidth/2, GetStgFrameHeight/2, 0);
	    ObjSprite2D_SetDestCenter(obj);
	    ObjRender_SetAlpha(obj, alpha);
	    ObjRender_SetBlendType(obj, BLEND_SUBTRACT);

	    let posY = GetStgFrameHeight/2;
	    let count = 0;
	    loop(60){
	    	alpha += 255/60;
	    	ObjRender_SetAlpha(obj, alpha);
	        ObjRender_SetAlpha(obj1, alpha);
	        posY -= 1.7;
	        count += 1.7;
	        if(count >= 384){
	            count = 0;
	            posY = GetStgFrameHeight/2;
	        }
	    	ObjRender_SetY(obj1, posY);
	        yield;
	    }
	    while(!Obj_IsDeleted(obj)){

	    	if(bSpell == false){
	    		loop(60){
	    			alpha -= 255/60;
	    			ObjRender_SetAlpha(obj, alpha);
	        		ObjRender_SetAlpha(obj1, alpha);
	        		posY -= 1.7;
			        count += 1.7;
			        if(count >= 384){
			            count = 0;
			            posY = GetStgFrameHeight/2;
			        }
			    	ObjRender_SetY(obj1, posY);
	        		yield;
	    		}
	    		Obj_Delete(obj);
	    		Obj_Delete(obj1);
	    	}
	        posY -= 1.7;
	        count += 1.7;
	        if(count >= 384){
	            count = 0;
	            posY = GetStgFrameHeight/2;
	        }
	    	ObjRender_SetY(obj1, posY);
	    	yield;
	    }
	}
}


function ObjMask_Create(texture_name, layer_min, layer_max){
	// Set up render target
	CreateRenderTarget(texture_name);

	// Set up shader
	let obj = ObjShader_Create();
	ObjShader_SetShaderF(obj, GetCurrentScriptDirectory() ~ "SamplePS02_HLSL.dnh");
	ObjShader_SetTechnique(obj, "TecMask");
	ObjShader_SetTexture(obj, "textureMask_", texture_name);
	SetShaderI(obj, layer_min, layer_max);

	Obj_SetValue(obj, "MASK_CONTENTS", []);

	task run(){
		while(!Obj_IsDeleted(obj)){
			let contents = Obj_GetValueD(obj, "MASK_CONTENTS", []);
			// Remove any deleted objects from list
			contents = remove_deleted_objs(contents);

			ascent(i in 0..length(contents)){
				// Make visible when drawing to render target
				//Obj_SetVisible(contents[i], true);
				Obj_SetVisible(contents[i], false);
				RenderToTextureB1(texture_name, contents[i], (i==0));
				// Otherwise invisible
				//Obj_SetVisible(contents[i], false);
			}

			Obj_SetValue(obj, "MASK_CONTENTS", contents);
			yield;
		}

		let contents = Obj_GetValueD(obj, "MASK_CONTENTS", []);
		ascent(i in 0..length(contents)){ Obj_Delete(contents[i]); }
		RemoveTexture(texture_name);
	}
	run();

	return obj;

	function remove_deleted_objs(a){
		let res = [0][0..0]; // typed array
		let slices = [];
		let prev = 0;
		ascent(i in 0..length(a)){
			if(Obj_IsDeleted(a[i])){
				slices = slices ~ [[prev, i]];
				prev = i+1;
			}
		}
		// if unchanged, return
		if(length(slices) == 0 && prev == 0){ return a; }
		// last slice
		slices = slices ~ [[prev, length(a)]];
		// join slices
		ascent(j in 0..length(slices)){
			res = res ~ a[slices[j][0]..slices[j][1]];
		}
		return res;
	}
}

function ObjMask_AddSource(obj, src){
	Obj_SetValue(obj, "MASK_CONTENTS", Obj_GetValueD(obj, "MASK_CONTENTS", []) ~ [src]);
}

task Shader{
	let c = 1;
	let circle = ObjPrim_Create(OBJ_SPRITE_2D);
	let circle1 = ObjPrim_Create(OBJ_SPRITE_2D);
	let alpha = 0;

    loop{
	    if(bSpell == true && stagepart == 0 && c == 0){
	    	alpha = 255;
	    	c ++;

			ObjPrim_SetTexture(circle, GetCurrentScriptDirectory() ~ "images/mask_subtract3.png");
			ObjSprite2D_SetSourceRect(circle, 0, 0, 768, 896);
			ObjRender_SetPosition(circle, GetCenterX + 32, GetCenterY + 16, 0);
			ObjSprite2D_SetDestCenter(circle);
			ObjRender_SetBlendType(circle, BLEND_SUBTRACT);
			ObjMask_AddSource(mask, circle);
			ObjRender_SetScaleXYZ(circle, 0, 0, 1);
			Appear(circle);

			let scaleX = 0;
			let scaleY = 0;
			loop(10){
				scaleX += 1.5/10;
				scaleY += 1.5/10;
				ObjRender_SetScaleXYZ(circle, scaleX, scaleY, 1);
				yield;
			}
			wait(80);

			ObjPrim_SetTexture(circle1, GetCurrentScriptDirectory() ~ "images/mask_subtract2.png");
			ObjSprite2D_SetSourceRect(circle1, 0, 0, 768, 896);
			ObjRender_SetPosition(circle1, GetCenterX + 32, GetCenterY + 16, 0);
			ObjSprite2D_SetDestCenter(circle1);
			ObjRender_SetBlendType(circle1, BLEND_SUBTRACT);
			ObjMask_AddSource(mask, circle1);
			Appear(circle1);

			ObjRender_SetScaleXYZ(circle1, 0, 0, 1);
			scaleX = 0;
			scaleY = 0;
			loop(10){
				scaleX += 1.5/10;
				scaleY += 1.5/10;
				ObjRender_SetScaleXYZ(circle1, scaleX, scaleY, 1);
				yield;
			}
			loop(120){
				scaleX += 4/120;
				scaleY += 4/120;
				ObjRender_SetScaleXYZ(circle, scaleX, scaleY, 1);
				ObjRender_SetScaleXYZ(circle1, scaleX, scaleY, 1);
				yield;
			}
			loop(60){
				scaleX += 15/60;
				scaleY += 15/60;
				ObjRender_SetScaleXYZ(circle, scaleX, scaleY, 1);
				ObjRender_SetScaleXYZ(circle1, scaleX, scaleY, 1);
				yield;
			}
			while(bSpell == true){
				yield;
			}
		}else if(bSpell == false && stagepart == 0 && c > 0){
			c = 0;
			loop(60){
				if(alpha > 0){
                	alpha -= 255/60;
            	}
				ObjRender_SetAlpha(circle, alpha);
				ObjRender_SetAlpha(circle1, alpha);
				yield;
			}
		}
		yield;
	}

	task Appear(obj){
		ObjRender_SetAlpha(obj, 0);
		wait(1);
		ObjRender_SetAlpha(obj, 255);
	}
}

task TDBG{
	let count = 0;
	CreateRenderTarget("3d");
	SetInvalidRenderPriorityA1(21, 23);
	RenderToTextureA1("3d", 21, 23, true);
	obj4 = ObjPrim_Create(OBJ_SPRITE_2D);
	ObjPrim_SetTexture(obj4, "3d");
	ObjSprite2D_SetSourceRect(obj4, 0 + 32, 0 + 16, 384 + 32, 448 + 16);
	ObjSprite2D_SetDestRect(obj4, 0, 0, 384, 448);
	Obj_SetRenderPriorityI(obj4, 25);
	ObjRender_SetAlpha(obj4, 255);
	let alpha = 255;
	while(!IsCloseScript(GetCommonData("Main Stage Script ID", 0))){
		if(GetCommonData("Delete", 0) == 1){
			let alp = 255;
			loop(60){
				alp -= 255/60;
				ObjRender_SetAlpha(obj4, alp);
				yield;
			}
			Obj_Delete(obj4);
			count = 0;
    	}
    	if(GetCommonData("Delete", 0) == 2 && count == 0){
    		count ++;
    		obj4 = ObjPrim_Create(OBJ_SPRITE_2D);
			ObjPrim_SetTexture(obj4, "3d");
			ObjSprite2D_SetSourceRect(obj4, 0 + 32, 0 + 16, 384 + 32, 448 + 16);
			ObjSprite2D_SetDestRect(obj4, 0, 0, 384, 448);
			Obj_SetRenderPriorityI(obj4, 25);
			ObjRender_SetAlpha(obj4, 0);
			let alp = 0;
			loop(60){
				alp += 255/60;
				ObjRender_SetAlpha(obj4, alp);
				yield;
			}
    	}
		yield;
	}
	ClearInvalidRenderPriority();
	bSpell = false;
}

function wait(n){
	loop(n){
		yield;
	}
}
function rand_int(min, max){
  return round(rand(min, max))
}
function GetCenterX(){
	return GetStgFrameWidth() / 2;
}

function GetCenterY(){
	return GetStgFrameHeight() / 2;
}
function MyStageID{
	return GetCommonData("Main Stage Script ID", 0);
}