#e[Package]
#Title["PluralBossRecords"]
#Text["PluralBossRecords"]
#System["./cmn/system/System.txt"]
#Player["./player/ReimuA.txt","./player/ReimuB.txt"]

#include "./cmn/SpellList.txt"
#include "./cmn/common.txt"
#include "./cmn/commonStage.txt"

let PlayerCharacter = 0;
let SoundFlag = 0;
let StageMusicFlag = 0;
let StageMusicStopFlag = 0;
let pageMaxSpell = 12;

@Initialize
{
	T_Main;
}

@MainLoop
{
	yield;
}

@Finalize
{
}

task T_Main
{
	// Z[uf[^Ǎ
	yield;
	if(LoadCommonDataAreaA1(SPELL_RECORD))
	{
		LoadCommonDataAreaA1(CONFIG);
	}
	else
	{
		let Spell_C_Array = [];
		let Spell_G_Array = [];
		let Spell_Score_Array = [];
		let Spell_First_Array = [];
		loop(36)
		{
			Spell_C_Array = Spell_C_Array ~ [0];
			Spell_G_Array = Spell_G_Array ~ [0];
			Spell_Score_Array = Spell_Score_Array ~ [0];
			Spell_First_Array = Spell_First_Array ~ [0];
		}
		CreateCommonDataArea(SPELL_RECORD);
		SetAreaCommonData(SPELL_RECORD,REIMU_A_CHALLENGE,Spell_C_Array);
		SetAreaCommonData(SPELL_RECORD,REIMU_A_GET,Spell_G_Array);
		SetAreaCommonData(SPELL_RECORD,REIMU_A_SCORE,Spell_Score_Array);
		SetAreaCommonData(SPELL_RECORD,REIMU_A_FIRST,Spell_First_Array);
		
		SetAreaCommonData(SPELL_RECORD,REIMU_B_CHALLENGE,Spell_C_Array);
		SetAreaCommonData(SPELL_RECORD,REIMU_B_GET,Spell_G_Array);
		SetAreaCommonData(SPELL_RECORD,REIMU_B_SCORE,Spell_Score_Array);
		SetAreaCommonData(SPELL_RECORD,REIMU_B_FIRST,Spell_First_Array);
		
		CreateCommonDataArea(CONFIG);
		SetAreaCommonData(CONFIG,CNF_BGM,1);
		SetAreaCommonData(CONFIG,CNF_CHARACTER,0);
		SetAreaCommonData(CONFIG,CNF_SELECT_INDEX,0);
		SetAreaCommonData(CONFIG,CNF_PAGE_INDEX,0);
		SetAreaCommonData(CONFIG,CNF_NAME,"AAA");
	}
	
	yield;
	
	T_TitleScene();
}

function CreateTextObject(let mx,let my,let text,let size,let bold,let topRGB,let btmRGB,let priority)
{
	let obj = ObjText_Create();
	ObjText_SetText(obj,text);
	ObjText_SetFontSize(obj,size);
	ObjText_SetFontBold(obj,bold);
	ObjText_SetFontColorTop(obj,topRGB[0],topRGB[1],topRGB[2]);
	ObjText_SetFontColorBottom(obj,btmRGB[0],btmRGB[1],btmRGB[2]);
	ObjText_SetFontBorderType(obj,BORDER_NONE);
//	ObjText_SetFontBorderColor(obj,255,255,255);
//	ObjText_SetFontBorderWidth(obj,2);
	Obj_SetRenderPriorityI(obj,priority);
	ObjRender_SetX(obj,mx);
	ObjRender_SetY(obj,my);
	ObjText_SetFontType(obj,"lr ");
	
	return obj;
}

//----------------------------------------------------
// ^CgV[
//----------------------------------------------------
task T_Sound
{
	SoundFlag++;
	if(SoundFlag >= 2){	return;	}
	if(GetAreaCommonData(CONFIG,CNF_BGM,1) == 0){	return;	}
	
	let objMusic = ObjSound_Create;
	ObjSound_Load(objMusic,GetCurrentScriptDirectory~"bgm/menu.mp3");
	ObjSound_SetLoopEnable(objMusic,true);
//	ObjSound_SetLoopTime(objMusic,46.439,107.369);
	if(SoundFlag >= 1)
	{
		ObjSound_Play(objMusic);
		ObjSound_SetVolumeRate(objMusic,80);
		while(SoundFlag >= 1){	yield;	}
		ObjSound_SetFade(objMusic,-40);
		loop(60){	yield;	}
	}
	Obj_Delete(objMusic);
}

task T_TitleScene
{
	let bEndTitleScene = false;	// ^CgV[ItO
	let SpellCardInfo_Text = [];	// \
	let G_Array = [];	// XyJ擾
	let C_Array = [];	// 
	let keyLock = 0;
	
	StageMusicFlag = 0;
	PlayerCharacter = GetAreaCommonData(CONFIG,CNF_CHARACTER,0);
	
	// wi
	let pathTitle = GetCurrentScriptDirectory() ~ "img/title.png";
	let objTitleImage = ObjPrim_Create(OBJ_SPRITE_2D);
	Obj_SetRenderPriorityI(objTitleImage,20);
	ObjPrim_SetTexture(objTitleImage,pathTitle);
	ObjSprite2D_SetSourceRect(objTitleImage,0,0,640,480);
	ObjSprite2D_SetDestRect(objTitleImage,0,0,640,480);
	
	// BGM
	T_Sound();
	
	// J^Cg
	let objTitleText = CreateTextObject(14,14,"A {X                                            ",14+4,true,[255,255,255],[160,160,255],30);
	
	// j[
	let selectIndex = GetAreaCommonData(CONFIG,CNF_SELECT_INDEX,0);
	let selectPageIndex = GetAreaCommonData(CONFIG,CNF_PAGE_INDEX,0);
	let MaxSelectPageIndex = 0;
	
	// j[̕\^XN
	task T_MenuItem()
	{
		let mx = 14;
		let my = 14 + 25;
		let objTextArray = [];
		let oldPage = selectPageIndex;
		let direct = 1;
		let BASE_ALPHA = "BASE_ALPHA";
		
		ascent(i in 0..(pageMaxSpell*2))
		{
			objTextArray = objTextArray ~ [CreateTextObject(mx,my+i%pageMaxSpell*25,"",14+4,true,[255,255,255],[127,127,127],72)];
			Obj_SetValue(objTextArray[i],BASE_ALPHA,0);
		}
		AlphaCont();
		
		while(!bEndTitleScene)
		{
			ascent(i in 0..pageMaxSpell)
			{
				if(length(SpellCardInfo_Text) > i+selectPageIndex*pageMaxSpell)
				{
					ObjText_SetText(objTextArray[i],SpellCardInfo_Text[i+selectPageIndex*pageMaxSpell]);
					// 擾XyJ͗ΐF\
					if(G_Array[i+selectPageIndex*pageMaxSpell] > 0)
					{
						ObjText_SetFontColorBottom(objTextArray[i],127,255,127);
					}
				}
				else
				{
					ObjText_SetText(objTextArray[i],"");
				}
			}
			yield;
			keyLock = 0;
			ascent(i in 0..pageMaxSpell)
			{
				Obj_SetValue(objTextArray[i],BASE_ALPHA,255);
			}
			while(oldPage == selectPageIndex)
			{
				if(GetVirtualKeyState(VK_RIGHT) == KEY_PUSH || GetVirtualKeyState(VK_RIGHT) == KEY_HOLD)
				{	direct = 1;	}
				if(GetVirtualKeyState(VK_LEFT) == KEY_PUSH || GetVirtualKeyState(VK_LEFT) == KEY_HOLD)
				{	direct = -1;	}
				if(bEndTitleScene){	break;	}
				yield;
			}
			if(bEndTitleScene){	break;	}
			// ̃y[W\
			ascent(i in 0..pageMaxSpell)
			{
				ObjRender_SetX(objTextArray[i],14+100*direct);
				if(length(SpellCardInfo_Text) > i+selectPageIndex*pageMaxSpell)
				{
					ObjText_SetText(objTextArray[i],SpellCardInfo_Text[i+selectPageIndex*pageMaxSpell]);
					if(G_Array[i+selectPageIndex*pageMaxSpell] > 0)
					{
						ObjText_SetFontColorBottom(objTextArray[i],127,255,127);
					}else
					{
						ObjText_SetFontColorBottom(objTextArray[i],127,127,127);
					}
				}
				else
				{
					ObjText_SetText(objTextArray[i],"");
				}
			}
			ascent(i in pageMaxSpell..(pageMaxSpell*2))
			{
				ObjRender_SetX(objTextArray[i],14);
				if(length(SpellCardInfo_Text) > i+oldPage*pageMaxSpell-pageMaxSpell)
				{
					ObjText_SetText(objTextArray[i],SpellCardInfo_Text[i+oldPage*pageMaxSpell-pageMaxSpell]);
					if(G_Array[i+oldPage*pageMaxSpell-pageMaxSpell] > 0)
					{
						ObjText_SetFontColorBottom(objTextArray[i],127,255,127);
					}else
					{
						ObjText_SetFontColorBottom(objTextArray[i],127,127,127);
					}
				}
				else
				{
					ObjText_SetText(objTextArray[i],"");
				}
			}
			oldPage = selectPageIndex;
			let AlphaRate = 0;
			let AlphaRate2 = 1;
			let Time = 10;
			keyLock = 1;
			loop(Time)
			{
				AlphaRate += (1/Time);
				ascent(i in 0..pageMaxSpell)
				{
					ObjRender_SetX(objTextArray[i],ObjRender_GetX(objTextArray[i])-100/Time*direct);
					Obj_SetValue(objTextArray[i],BASE_ALPHA,AlphaRate*255);
				}
				AlphaRate2 -= (1/Time);
				ascent(i in pageMaxSpell..(pageMaxSpell*2))
				{
					ObjRender_SetX(objTextArray[i],ObjRender_GetX(objTextArray[i])-100/Time*direct);
					Obj_SetValue(objTextArray[i],BASE_ALPHA,AlphaRate2*255);
				}
				yield;
			}
		}
		ascent(i in 0..(pageMaxSpell*2))
		{
			Obj_Delete(objTextArray[i]);
		}
		
		task AlphaCont()
		{
			while(!bEndTitleScene)
			{
				ascent(i in 0..(pageMaxSpell*2))
				{
					ObjRender_SetAlpha(objTextArray[i],Obj_GetValue(objTextArray[i],BASE_ALPHA));
				}
				yield;
			}
		}
	}	// task T_MenuItem
	
	//j[zu
	alternative(PlayerCharacter)
	case(0){G_Array = GetAreaCommonData(SPELL_RECORD,REIMU_A_GET,[]);}
	case(1){G_Array = GetAreaCommonData(SPELL_RECORD,REIMU_B_GET,[]);}
	alternative(PlayerCharacter)
	case(0){C_Array = GetAreaCommonData(SPELL_RECORD,REIMU_A_CHALLENGE,[]);}
	case(1){C_Array = GetAreaCommonData(SPELL_RECORD,REIMU_B_CHALLENGE,[]);}
	
	ascent(i in 0..length(SpellCardName))
	{
		SpellCardInfo_Text = SpellCardInfo_Text ~ [""];
		if(SpellCardName[i] != "")
		{
			let AddStr = "";
			if(i+1 < 10)
			{
				AddStr = "00" ~ IntToString(i+1);
			}
			else if(i+1 < 100)
			{
				AddStr = "0" ~ IntToString(i+1);
			}
			else
			{
				AddStr = IntToString(i+1);
			}
			while(length(AddStr) < 5)
			{
				AddStr = AddStr ~ " ";
			}
			SpellCardInfo_Text[i] = AddStr ~ SpellCardName[i];
			while(length(SpellCardInfo_Text[i]) < 55)
			{
				SpellCardInfo_Text[i] = SpellCardInfo_Text[i] ~ "@";
			}
			AddStr = IntToString(G_Array[i]);
			SpellCardInfo_Text[i] = SpellCardInfo_Text[i] ~ AddStr;
			AddStr = " / ";
			SpellCardInfo_Text[i] = SpellCardInfo_Text[i] ~ AddStr;
			AddStr = IntToString(C_Array[i]);
			SpellCardInfo_Text[i] = SpellCardInfo_Text[i] ~ AddStr;
		}
	}
	yield;
	T_MenuItem();
	
	yield;	// ŷ1t[炷
	
	SelectEffect;
	Explain;
	
	//L[ԂZbg܂őҋ@
	while(GetVirtualKeyState(VK_OK) != KEY_FREE){	yield;	}
	
	//j[I
	let frameKeyHold = 0;	// L[ςȂt[
	MaxSelectPageIndex = ceil(length(SpellCardName) / pageMaxSpell);
	let pathScript = GetCurrentScriptDirectory() ~ "./cmn/system/Pause.txt";
	
	loop
	{
		SetAreaCommonData(CONFIG,CNF_SELECT_INDEX,selectIndex);
		SetAreaCommonData(CONFIG,CNF_PAGE_INDEX,selectPageIndex);
		SetAreaCommonData(CONFIG,CNF_CHARACTER,PlayerCharacter);
		
		while(keyLock == 1){	yield;	}
		//
		if(GetVirtualKeyState(VK_OK) == KEY_PUSH)
		{
			if(SpellCardName[selectIndex+selectPageIndex*pageMaxSpell] != ""){
				SetSpellCardNumber(SpellCardName[selectIndex+selectPageIndex*pageMaxSpell]);
				SetCommonData(CNF_CHARACTER,PlayerCharacter);
				T_StageScene("");
				break;
			}
		}
		if(GetVirtualKeyState(VK_PAUSE) == KEY_PUSH)
		{
			let idScript = LoadScript(pathScript);
			StartScript(idScript);
			yield;
//			PauseStageScene(true);
			while(!IsCloseScript(idScript))
			{
				yield;
			}
//			PauseStageScene(false);
			let result = GetScriptResult(idScript);
			if(result == RESULT_END)
			{
				ClosePackage();
			}
		}
		//J[\ړ
		if(GetVirtualKeyState(VK_UP) == KEY_PUSH)
		{
			selectIndex--;
		}
		else if(GetVirtualKeyState(VK_DOWN) == KEY_PUSH)
		{
			selectIndex++;
		}
		else if(GetVirtualKeyState(VK_UP) == KEY_HOLD)
		{
			frameKeyHold++;
			if(frameKeyHold == 24 || (frameKeyHold > 24 && (frameKeyHold % 8 == 0)))
			{
				selectIndex--;
			}
		}
		else if(GetVirtualKeyState(VK_DOWN) == KEY_HOLD)
		{
			frameKeyHold++;
			if(frameKeyHold == 24 || (frameKeyHold > 24 && (frameKeyHold % 8 == 0)))
			{
				selectIndex++;
			}
		}
		else if(GetVirtualKeyState(VK_LEFT) == KEY_PUSH)
		{
			selectPageIndex--;
			if(selectPageIndex < 0)
			{
				selectPageIndex = MaxSelectPageIndex - 1;
			}
		}
		else if(GetVirtualKeyState(VK_RIGHT) == KEY_PUSH)
		{
			selectPageIndex++;
			if(selectPageIndex >= MaxSelectPageIndex)
			{
				selectPageIndex = 0;
			}
		}
		else if(GetVirtualKeyState(VK_LEFT) == KEY_HOLD)
		{
			frameKeyHold++;
			if(frameKeyHold == 24 || (frameKeyHold > 24 && (frameKeyHold % 8 == 0)))
			{
				selectPageIndex--;
				if(selectPageIndex < 0)
				{
					selectPageIndex = MaxSelectPageIndex - 1;
				}
			}
		}
		else if(GetVirtualKeyState(VK_RIGHT) == KEY_HOLD)
		{
			frameKeyHold++;
			if(frameKeyHold == 24 || (frameKeyHold > 24 && (frameKeyHold % 8 == 0)))
			{
				selectPageIndex++;
				if(selectPageIndex >= MaxSelectPageIndex)
				{
					selectPageIndex = 0;
				}
			}
		}
		else
		{
			frameKeyHold = 0;
		}
		
		if(GetVirtualKeyState(VK_BOMB) == KEY_PUSH)
		{
			PlayerCharacter++;
			PlayerCharacter = PlayerCharacter % 2;
			SetAreaCommonData(CONFIG,CNF_CHARACTER,PlayerCharacter);
			bEndTitleScene = true;
			yield;
			T_TitleScene;
			break;
		}
		
		if(GetVirtualKeyState(VK_USER1) == KEY_PUSH)
		{
			yield;
			T_ReplaySelectScene();
			break;
		}
		
		if(selectIndex < 0) 
		{
			if(selectPageIndex == MaxSelectPageIndex - 1)
			{
				selectIndex = length(SpellCardName) % pageMaxSpell - 1;
				if(selectIndex < 0)
				{
					selectIndex = pageMaxSpell - 1;
				}
			}
			else
			{
				selectIndex = pageMaxSpell - 1;
			}
		}
		else
		{
			if(selectPageIndex == MaxSelectPageIndex - 1 && length(SpellCardName) % pageMaxSpell != 0)
			{
				if(selectIndex > length(SpellCardName) % pageMaxSpell - 1)
				{
					selectIndex = 0;
				}
			}
			selectIndex %= pageMaxSpell;
		}
		
		yield;
	}
	
	bEndTitleScene = true;
	Obj_Delete(objTitleImage);
	Obj_Delete(objTitleText);
	
	// ݑIĂXyJɃGtFNgt
	task SelectEffect
	{
		let y = 0;
		let obj = ObjPrim_Create(OBJ_SPRITE_2D);
		ObjPrim_SetTexture(obj,GetCurrentScriptDirectory()~"img/white.png");
		ObjSprite2D_SetSourceRect(obj,0,0,10,10);
		ObjRender_SetColor(obj,191,127,127);
		ObjRender_SetAlpha(obj,127);
		Obj_SetRenderPriority(obj,0.2);
		
		while(!bEndTitleScene){
			y = 39 + 25 * selectIndex;
			ObjSprite2D_SetDestRect(obj,0,y+10,GetScreenWidth(),y+20);
			yield;
		}
		Obj_Delete(obj);
	}
	
	// XyJ𓙕\
	task Explain
	{
		UnderExplain;
		
		let objText2 = CreateTextObject(14,352+20,"擾퐔@"~"N/A",18,true,[255,255,255],[128,255,192],72);
		let objText3 = CreateTextObject(14,352+20*2,"ōXRA@@"~"N/A",18,true,[255,255,255],[128,255,192],72);
		let objText5 = CreateTextObject(504,352,"Page@"~"1 / "~IntToString(MaxSelectPageIndex),18,true,[255,255,255],[160,160,255],72);
		let objText6 = CreateTextObject(356,352+20*1,"擾@@@"~"18/42",18,true,[255,255,255],[128,255,192],72);
		let objText7 = CreateTextObject(356,352+20*2,"ōXRA@",18,true,[255,255,255],[128,255,192],72);
		let objText9 = CreateTextObject(14,352+20*4+8,"Player@"~"@얲",18,true,[255,255,255],[128,255,192],72);

		let TotalSCNum = length(SpellCardName);
		let TotalGet = 0;
		let TotalScore = 0;
		let S_Array=[];
		alternative(PlayerCharacter)
		case(0){S_Array = GetAreaCommonData(SPELL_RECORD,REIMU_A_SCORE,[]);}
		case(1){S_Array = GetAreaCommonData(SPELL_RECORD,REIMU_B_SCORE,[]);}
		let F_Array=[];
		alternative(PlayerCharacter)
		case(0){F_Array = GetAreaCommonData(SPELL_RECORD,REIMU_A_FIRST,[]);}
		case(1){F_Array = GetAreaCommonData(SPELL_RECORD,REIMU_B_FIRST,[]);}
		
		if(PlayerCharacter == 0)
		{
			ObjText_SetText(objText9,"Player@"~"얲@");
		}
		else if(PlayerCharacter == 1)
		{
			ObjText_SetText(objText9,"Player@"~"얲@아");
		}
		
		ascent(i in 0..length(SpellCardName))
		{
			if(SpellCardName[i] == ""){
				TotalSCNum--;
			}
			if(G_Array[i] >= 1)
			{
				TotalGet += 1;
			}
			if(S_Array[i] >= 0)
			{
				TotalScore += S_Array[i];
			}
		}
		
		while(!bEndTitleScene)
		{
			if(F_Array[selectIndex+selectPageIndex*pageMaxSpell] != 0)
			{
				ObjText_SetText(objText2,"擾퐔@"~IntToString(F_Array[selectIndex+selectPageIndex*pageMaxSpell]));
			}else{
				ObjText_SetText(objText2,"擾퐔@N/A");
			}
			if(S_Array[selectIndex+selectPageIndex*pageMaxSpell] != 0)
			{
				ObjText_SetText(objText3,"ōXRA@@"~IntToString(S_Array[selectIndex+selectPageIndex*pageMaxSpell]));
			}else{
				ObjText_SetText(objText3,"ōXRA@@N/A");
			}
			ObjText_SetText(objText5,"Page@"~IntToString(selectPageIndex+1)~" / "~IntToString(MaxSelectPageIndex));
			ObjText_SetText(objText6,"擾@@@"~IntToString(TotalGet)~"@/@"~IntToString(TotalSCNum));
			ObjText_SetText(objText7,"ōXRA@"~IntToString(TotalScore));
			
			yield;
		}
		Obj_Delete(objText2);
		Obj_Delete(objText3);
		Obj_Delete(objText5);
		Obj_Delete(objText6);
		Obj_Delete(objText7);
		Obj_Delete(objText9);
	}
	
	// \
	task UnderExplain
	{
		let obj = CreateTextObject(14,464,"Shot:  Bomb:ύX  User1:vC  Pause:j[",12,true,[255,255,255],[255,255,255],30);
//		let AlphaAngle = 0;
		while(!bEndTitleScene)
		{
//			ObjRender_SetAlpha(obj,200+55*cos(AlphaAngle));
//			AlphaAngle += 2;
			yield;
		}
		Obj_Delete(obj);
	}
}

//----------------------------------------------------
// Xe[WV[
//----------------------------------------------------
task T_StageScene(let pathReplay)
{
	let dirCurrent = GetCurrentScriptDirectory();
	let dirModule = GetModuleDirectory();
	let pathMainScript = dirCurrent ~ "./Stage.txt";
	let pathPlayer = dirCurrent ~ "player/ReimuA.txt";
	if(PlayerCharacter == 1)
	{
		pathPlayer = dirCurrent ~ "player/ReimuB.txt";
	}
	
	// ʑJ
	RenderSceneToTransitionTexture();
	T_Transition();
	SoundFlag = 0;
	
	// Xe[W
	InitializeStageScene();
	if(length(pathReplay) > 0)
	{
		SetStageReplayFile(pathReplay);
	}
	let indexStage = 1 + 1;	//Xe[WCfbNX
	SetStageIndex(indexStage);
	SetStageMainScript(pathMainScript);
	SetStagePlayerScript(pathPlayer);
	StartStageScene();
	
	T_StageSound();
	
	SaveRecord;
	
	// Xe[W
	loop
	{
		//ꎞ~`FbN
		if(GetVirtualKeyState(VK_PAUSE) == KEY_PUSH)
		{
			let resPause = RunPauseScene();
			alternative(resPause)
			case(RESULT_RETRY)
			{
				//ŏ蒼
				if(!IsReplay())
				{
					//gC
					TerminateStageScene();
					T_StageScene("");
					return;
				}
			}
			case(RESULT_END)
			{
				//ꎞ~̏I
				TerminateStageScene();
			}
		}
		
		// Xe[W҂
		let stgSceneState = GetStageSceneState();
		if(stgSceneState == STAGE_STATE_FINISHED)
		{
			let stageResult = GetStageSceneResult();
			alternative(stageResult)
			case(STAGE_RESULT_CLEARED)
			{
				// Xe[WNA
//				if(indexStage == 2)
//				{
					if(IsReplay)
					{
						T_EndScene();
					}
					else
					{
						T_ClearScene();
					}
					break;
//				}
			}
			case(STAGE_RESULT_PLAYER_DOWN)
			{
				//@c@0
				T_EndScene();
				break;
			}
			case(STAGE_RESULT_BREAK_OFF)
			{
				//Xe[WrI
				//ꎞ~̏I
				if(IsReplay)
				{
					T_EndScene();
				}
				else
				{
					T_TitleScene();
				}
				break;
			}
		}
		yield;
	}
	
	T_Transition();
}

task T_StageSound
{
	StageMusicFlag++;
	if(StageMusicFlag >= 2){	return;	}
	if(GetAreaCommonData(CONFIG,CNF_BGM,1) == 0){	return;	}
	
	let StageMusicObject = ObjSound_Create;
	SetCommonData("MusicStep",0);
	ObjSound_Load(StageMusicObject,GetCurrentScriptDirectory~"bgm/bgm1.mp3");
	ObjSound_SetLoopEnable(StageMusicObject,true);
//	ObjSound_SetLoopTime(StageMusicObject,47.297,169.970);
	ObjSound_SetSoundDivision(StageMusicObject,SOUND_BGM);
	ObjSound_Play(StageMusicObject);
	ObjSound_SetRestartEnable(StageMusicObject,true);
	let CurrentVulume = 1;
	while(StageMusicFlag > 0)
	{
		if(StageMusicStopFlag)
		{
			ObjSound_Stop(StageMusicObject);
			ObjSound_SetVolumeRate(StageMusicObject,0);
			CurrentVulume = 0;
			while(StageMusicStopFlag)
			{
				yield;
				if(StageMusicFlag == 0)
				{
					Obj_Delete(StageMusicObject);
					return;
				}
			}
			ObjSound_Play(StageMusicObject);
		}
		else
		{
			if(CurrentVulume != 1){
				if(CurrentVulume < 1){CurrentVulume += 0.05;}
				ObjSound_SetVolumeRate(StageMusicObject,100*CurrentVulume);
			}
		}
		if(GetCommonData("BossDefeat",false))
		{
			loop(240)
			{
				CurrentVulume -= 1/240;
				ObjSound_SetVolumeRate(StageMusicObject,100*CurrentVulume);
				yield;
			}
			loop
			{
				yield;
				if(StageMusicFlag == 0){	break;	}
			}
		}
		yield;
	}
	
	Obj_Delete(StageMusicObject);
}

//----------------------------------------------------
// IV[
//----------------------------------------------------
task T_ClearScene()
{
	if(IsReplay())
	{
		T_TitleScene();
		return;
	}
	
	// Xe[WI
	FinalizeStageScene();
	
	// IV[XNvgN
	let dirModule = GetModuleDirectory();
	let pathScript = GetCurrentScriptDirectory() ~ "./cmn/system/ClearScene.txt";
	let idScript = LoadScript(pathScript);
	StartScript(idScript);
	
	while(!IsCloseScript(idScript))
	{
		yield;
	}
	
	//IV[ʏ
	SaveRecord;
	
	let result = GetScriptResult(idScript);
	alternative(result)
	case(RESULT_SAVE_REPLAY)
	{
		//vCۑ
		T_ReplaySaveScene();
	}
	case(RESULT_END)
	{
		//ĐI
		T_TitleScene();
	}
	case(RESULT_RETRY)
	{
		//gC
		T_StageScene("");
	}
}

task T_EndScene()
{
	if(IsReplay())
	{
		StageMusicFlag = 0;
		T_Sound;
		T_ReplaySelectScene();
		return;
	}
	
	//Xe[WI
	FinalizeStageScene();
	
	//IV[XNvgN
	let dirModule = GetModuleDirectory();
	let pathScript = GetCurrentScriptDirectory() ~ "./cmn/system/ClearScene.txt";
	let idScript = LoadScript(pathScript);
	StartScript(idScript);
	
	while(!IsCloseScript(idScript))
	{
		yield;
	}
	
	//IV[ʏ
	SaveRecord;
	
	let result = GetScriptResult(idScript);
	alternative(result)
	case(RESULT_SAVE_REPLAY)
	{
		//vCۑ
		T_ReplaySaveScene();
	}
	case(RESULT_END)
	{
		//ĐI
		T_TitleScene();
	}
	case(RESULT_RETRY)
	{
		//gC
		T_StageScene("");
	}
}

//----------------------------------------------------
// ꎞ~V[
//----------------------------------------------------
function RunPauseScene()
{
	StageMusicStopFlag=1;
	RenderSceneToTransitionTexture();
	PauseStageScene(true);

	let dirModule = GetModuleDirectory();
	let pathScript = GetCurrentScriptDirectory() ~ "./cmn/system/PauseStage.txt";

	//--------------------------------
	//ꎞ~V[XNvgN
	let idScript = LoadScript(pathScript);
	StartScript(idScript);

	while(!IsCloseScript(idScript))
	{
		yield;
	}
	StageMusicStopFlag=0;
	PauseStageScene(false);

	let res = GetScriptResult(idScript);
	return res;
}

//----------------------------------------------------
// vCIV[
//----------------------------------------------------
task T_ReplaySelectScene()
{
	let dirCurrent = GetCurrentScriptDirectory();
	let pathScript = dirCurrent ~ "./cmn/system/ReplaySelectScene.txt";
	
	// vCIV[XNvgN
	let idScript = LoadScript(pathScript);
	StartScript(idScript);
	
	while(!IsCloseScript(idScript))
	{
		yield;
	}
	
	// vCIV[ʏ
	let result = GetScriptResult(idScript);
	
	if(length(result) == 0)
	{
		// ^CgV[֖߂
		T_TitleScene();
	}
	else
	{
		// vCĐJn
		T_StageScene(result);
	}
}

//----------------------------------------------------
// fV[
//----------------------------------------------------
/*
task DemoScene()
{
	DemoFlag=1;
	let dirCurrent = GetCurrentScriptDirectory();
	let pathScript = dirCurrent ~ "system/DemoScene.txt";

	//--------------------------------
	//vCIV[XNvgN
	let idScript = LoadScript(pathScript);
	StartScript(idScript);

	while(!IsCloseScript(idScript))
	{
		yield;
	}

	let result = GetScriptResult(idScript);

	TStageScene(result);
}
*/

//----------------------------------------------------
// vCۑV[
//----------------------------------------------------
task T_ReplaySaveScene()
{
	let dirCurrent = GetCurrentScriptDirectory();
	let pathScript = dirCurrent ~ "./cmn/system/ReplaySaveScene.txt";
	
	// vCۑV[XNvgN
	let idScript = LoadScript(pathScript);
	StartScript(idScript);
	
	while(!IsCloseScript(idScript))
	{
		yield;
	}
	
	//^CgV[֑J
	T_TitleScene();
}

//----------------------------------------------------
// ʑJڃGtFNg
//----------------------------------------------------
function RenderSceneToTransitionTexture()
{
	//݂̃V[eʑJڗpeNX`ɕ`
	let textureName = GetTransitionRenderTargetName();
	RenderToTextureA1(textureName,0,100,true);
}

task T_Transition
{
	let textureName = GetTransitionRenderTargetName();
	
	let objImage = ObjPrim_Create(OBJ_SPRITE_2D);
	Obj_SetRenderPriorityI(objImage,100);
	ObjPrim_SetTexture(objImage,textureName);
	ObjSprite2D_SetSourceRect(objImage,0,0,640,480);
	ObjSprite2D_SetDestRect(objImage,0,0,640,480);
	
	let alpha = 255;
	while(alpha > 0)
	{
		ObjRender_SetAlpha(objImage,alpha);
		alpha -= 16;
		yield;
	}
	Obj_Delete(objImage);
}

//----------------------------------------------------
// Z[u
//----------------------------------------------------
function SaveRecord
{
	if(!IsReplay())
	{
		SaveCommonDataAreaA1(SPELL_RECORD);
		SaveCommonDataAreaA1(CONFIG);
	}
}
