#TouhouDanmakufu[Package]
#Title["Heart's EverLasting Lunacy"]
#Text["Package"]
#include "./lib_sound.dnh"
let CSD = GetCurrentScriptDirectory;
let cc = 0;
let timer = 0;

let changeIndex = 0;

let stageCounter = 1;

let TitleIndex = 1;
let fixTitleIndex = 0;
let restriction = 1;

let selectIndex = 0;

let ContinueCount = 0;

let indexText = ObjText_Create();

function wait(n){
	loop(n){yield;}
}

function rand_int(min, max){
  return round(rand(min, max))
}

@Initialize{
	SetCommonData("Practice", 0);
	SetCommonData("Continues", ContinueCount);
    TTitle;
}

@MainLoop{
    ObjText_SetText(indexText, selectIndex);
	if(GetCommonData("inc", 0) != cc){
		cc = GetCommonData("inc", 0);
		timer = 0;
	}
	if(cc == GetCommonData("inc", 0)){
		timer ++;
	}
    yield;
}

@Finalize{

}

task TTitle{

    MainMenu;

}

task MainMenu{
	TitleIndex = 1;
	selectIndex = 0;
    let pathImg = CSD ~ "images/TitleItems.png";

    let INDEX_START = 0;
    let INDEX_PRACTICE = 2;

    let frameKeyHold = 0;
    while(TitleIndex == 1){
        if(GetVirtualKeyState(VK_OK) == KEY_PUSH){
        	alternative(selectIndex)
        	case(INDEX_START){
        		SetCommonData("Practice", 0);
                DifficultyMenu;
                break;
        	}
        }

        yield;
    }
}

task DifficultyMenu{
	TitleIndex = 2;
	selectIndex = 1;

    let frameKeyHold = 0;
    while(TitleIndex == 2){
        if(GetVirtualKeyState(VK_OK) == KEY_PUSH && 4 > selectIndex){
        	alternative(selectIndex)
 			...
        	CharacterSelect(2);
        }

        yield;
    }
}

task CharacterSelect(reservedIndex){
	TitleIndex = 3;
	selectIndex = 0;

	let frameKeyHold = 0;

	while(TitleIndex == 3){

		if(GetVirtualKeyState(VK_OK) == KEY_PUSH && 4 > selectIndex){
        	alternative(selectIndex)
        	case(0){
        		SetCommonData("PlayerID", 1);
        	}
        	case(1){
        		SetCommonData("PlayerID", 2);
        	}
        	alternative(reservedIndex)
        	case(2){
        		TStageScene("", 1);
	            TitleIndex = 0;
	            ClearInvalidRenderPriority();
	            SetAreaCommonData("Boss Spell", "Active", false);
	            SaveCommonDataAreaA2("Boss Spell", "./CDarea.dnh");
        	}
        }

		yield;
	}
}

task TStageScene(pathReplay, continue){
    let titleSceneEnd = false;
    let CSD = GetCurrentScriptDirectory;
    let MD = GetModuleDirectory;
    let pathMainScript;
    let diff = GetAreaCommonData("Difficulty", "diff", 1);
    alternative(diff)
    case(0){
        pathMainScript = CSD ~ "(" ~ itoa(stageCounter) ~ ")Stage (E).dnh";
    }

    SetCommonData("StageNum", stageCounter);
    let pathPlayer1 = MD;
    if(GetCommonData("PlayerID", 1) == 1){
    	pathPlayer1 = MD ~ "script/player/ReimuA/playerreimu.dnh";
    }else if(GetCommonData("PlayerID", 1) == 2){
    	pathPlayer1 = MD ~ "script/player/MarisaA/playermarisa.dnh";
    }

    RenderSceneToTransitionTexture();
    TTransition();

    InitializeStageScene();

    if(length(pathReplay) > 0){
        SetStageReplayFile(pathReplay);
    }

    let indexStage = 1;
    SetStageIndex(indexStage);
    SetStageMainScript(pathMainScript);
    SetStagePlayerScript(pathPlayer1);
    StartStageScene();

    loop{
        //----------------------------------------
        if(GetVirtualKeyState(VK_PAUSE) == KEY_PUSH && GetCommonData("MenuWork", 0) == 0){
            let resPause = RunPauseScene();
            alternative(resPause)

            case(RESULT_RETRY){
                if(!IsReplay()){
                    TerminateStageScene();
                    TStageScene("", 1);
                    return;
                }
            }

            case(RESULT_END){
                TerminateStageScene();
            }
        }
        //----------------------------------------
        if(!IsReplay() && GetKeyState(KEY_BACK) == KEY_PUSH){
            TerminateStageScene();
            TStageScene("", 1);
            return;
        }
        //----------------------------------------
        if(GetCommonData("ContinueUse", 0) == 1){
	        ContinueScreen;
	        SetCommonData("ContinueUse", 0)
        }
        //----------------------------------------
        if(GetCommonData("StageRestart", 0) == 1){
        	SetCommonData("StageRestart", 0);
        	if(!IsReplay()){
                    TerminateStageScene();
                    TStageScene("", 1);
                    return;
                }
        }
        let stgSceneState = GetStageSceneState();
        if(stgSceneState == STAGE_STATE_FINISHED){
            let stageResult = GetStageSceneResult();
            alternative(stageResult)
            //-------------------------------------------------------
			...
            //------------------------------------------------------
            /*case(STAGE_RESULT_PLAYER_DOWN){
                TEndScene();
                break;
            }*/
            //------------------------------------------------------
            case(STAGE_RESULT_BREAK_OFF){
                TTitle;
                break;
            }
            //------------------------------------------------------
        }
        yield;
    }
    TTransition();
}

task ContinueScreen{
	wait(30);
	SetCommonData("MenuWork", 1);
	SaveSnapShotA1("script/Tutorial/images/screensave.png");
	RenderSceneToTransitionTexture();
    PauseStageScene(true);

	let pathScript = GetCurrentScriptDirectory ~ "system/Continue.dnh";
	let idScript = LoadScript(pathScript);
	StartScript(idScript);

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

	let result = GetScriptResult(idScript);
	alternative(result)
	case(0){
		SetCommonData("MenuWork", 0);
		ContinueCount --;
		SetCommonData("Continues", ContinueCount);
		NotifyEventAll(EV_USER + 8, 2);
		PauseStageScene(false);
	}
	case(1){
		SetCommonData("MenuWork", 0);
		NotifyEventAll(EV_USER + 8, -1);
		TerminateStageScene;
		PauseStageScene(false);
	}
	case(2){
		TReplaySaveScene;
	}
	case(3){
		SetCommonData("MenuWork", 0);
		SetCommonData("StageRestart", 1);
		if(GetCommonData("Practice", 0) == 0){
			stageCounter = 1;
		}
		PauseStageScene(false);
	}
}

task TReplaySaveScene{
    let dirModule = GetModuleDirectory();
	let pathScript = dirModule ~ "script/default_system/Default_ReplaySaveScene.txt";

	let idScript = LoadScript(pathScript);
	StartScript(idScript);

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

	SetCommonData("MenuWork", 0);
	TerminateStageScene;
}

task TEndScene(){
    if(IsReplay())
    {
        TTitle;
        return;
    }

    FinalizeStageScene();

    let pathScript = GetCurrentScriptDirectory ~ "system/EndScene.dnh";
    let idScript = LoadScript(pathScript);
    StartScript(idScript);

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

    //--------------------------------
    let result = GetScriptResult(idScript);
    alternative(result)
    case(RESULT_END){
        TTitle;
    }
    case(RESULT_RETRY){
        TStageScene("", 1);
    }
}