#include "ScenePlay.h"
#include "SceneManager.h"
#include "Dxlib.h" 

#define DEL_MIN     4
#define PANEL_SIZE 12
#define BLOCK_NO 15


int g_PlayCG;
int g_PlyBGM;
int g_Block[16];	// 画像を入れる変数 
int g_Corsor,g_Corsor2;	//カーソル
int g_Count,g_Count2;	//カーソルの移動先
int g_Time;
int g_NewTime;
int g_OldTime;		//制限時間用の変数
int g_Panel[PANEL_SIZE][PANEL_SIZE];	//パネルの大きさ12*12マス
int g_DelCountW,g_DelCountH;
int g_DeletePanelW[PANEL_SIZE][PANEL_SIZE],g_DeletePanelH[PANEL_SIZE][PANEL_SIZE]; // 1なら消える
/*int g_CheckPanelW[PANEL_SIZE][PANEL_SIZE],g_CheckPanelH[PANEL_SIZE][PANEL_SIZE]; // 1ならチェック済み*/

void UpdateTime(void);
void SearchDelBlock(void);
void SearchDelBlockW(int h, int w);
void SearchDelBlockH(int h, int w);
int FallBlock(void);
void DrawStage(void);




void InitializePlay(void)
{
	int h,w;
//_____________________________________________________________________
//
//				画像読み込み
//_____________________________________________________________________
		
	LoadDivGraph( "CG/BLOCK.png" , 16 , 4 , 4 , 32 , 32 , g_Block );
	g_PlayCG = LoadGraph("CG/iris.png");
	g_PlyBGM = LoadSoundMem( "SOUND/今宵.mp3" );
//_____________________________________________________________________

//---------------------

	g_Corsor = 0;
	g_Corsor2 = 0;
//---------------------
	
	g_Count =0;
	g_Count2 = 0;

//---------------------
	g_Time = 0;
	g_NewTime = GetNowCount();
	g_OldTime = GetNowCount();
//---------------------

	for( h = 0; h < PANEL_SIZE ; h++)
	{
		for( w = 0; w < PANEL_SIZE; w++)
		{
			g_Panel[h][w] = GetRand(4);
		}
	}
}


void UpdatePlay(void)
{
	UpdateTime();

	if( g_Key[ KEY_INPUT_RIGHT ] == 1 && g_Count2 < 10){	//→を押したら
		g_Corsor += 32 ;
		g_Count2++;
	}
	else if( g_Key[ KEY_INPUT_LEFT  ] == 1 && g_Count2 > 0 ){	//←を押したら
		g_Corsor -= 32;
		g_Count2--;
	}
	else if( g_Key[ KEY_INPUT_DOWN  ] == 1 && g_Count < 11 ){	//↓を押したら	
		g_Corsor2 += 32 ;
		g_Count++;
	}
	else if( g_Key[ KEY_INPUT_UP    ] == 1 && g_Count > 0){	//↑を押したら
		g_Corsor2 -= 32;
		g_Count--;
	}


	if(g_Key[KEY_INPUT_SPACE]==1){	//SPACEKEYが押されたら
		
		int panel;

		panel = g_Panel[g_Count][g_Count2];
			
		g_Panel[g_Count][g_Count2] = g_Panel[g_Count][g_Count2+1];
			
		g_Panel[g_Count][g_Count2+1] = panel;
	}

	/*SearchDelBlock();
	FallBlock();*/



	//デバッグ用
	if(g_Key[KEY_INPUT_X]==1){	//X KEYが押されたら
		ChangeScene(SCENE_OPENING);	
	}
}


void DrawPlay(void)
{
	DWORD color;

	//バックに置くCG
	DrawRotaGraph( 320, 240, 1.1, 0.0, g_PlayCG, TRUE );	
	//BGM描画
	ChangeVolumeSoundMem( 255 * 20 / 100, g_PlyBGM) ;
	PlaySoundMem( g_PlyBGM, DX_PLAYTYPE_LOOP, false );

	DrawStage();


//****************************************************
//					カーソルのCG
//****************************************************
	SetDrawBlendMode( DX_BLENDMODE_ALPHA,  120 );
	DrawGraph(g_Corsor, g_Corsor2, g_Block[9], TRUE );
	DrawGraph(g_Corsor +32, g_Corsor2 , g_Block[9], TRUE );
	SetDrawBlendMode( DX_BLENDMODE_NOBLEND,  0 );
//====================================================

	//制限時間を描画
	color = GetColor( 60 , 200 , 120 ) ; // 紫色の値を取得
	DrawFormatString(0,400, color , "計算時間%d秒", g_Time);

	DrawBox(  10 , 430 , 300 , 440 , color , FALSE) ;		  // 四角形を描画(枠のみ)
    DrawBox(  10 , 430 , 300-g_Time , 440 , color , TRUE ) ;   // 四角形を描画(塗りつぶし)
}


void FinalizePlay(void)
{
	InitGraph();
	InitSoundMem();
}


void UpdateTime(void)
{
	g_NewTime = GetNowCount();
	if( g_NewTime - g_OldTime > 1000.0 )
	{
		g_Time++;
		g_OldTime = g_NewTime;
	}
}

//==============================================================================================
// 消えるブロックの検索
//==============================================================================================
void SearchDelBlock(void){

	int h,w;

    for( h = 0; h < PANEL_SIZE; h++)
	{
		for( w = 0; w < PANEL_SIZE; w++)
		{
			if(g_DeletePanelW[h][w] == 0)
			{ // まだ消えていないブロックなら…
            
				SearchDelBlockW(h, w); // 再帰ルーチン(横)スタート

				if(g_DelCountW >= DEL_MIN)
				{ // 消えるなら…
					for(int h2 = 0; h2 < PANEL_SIZE; h2++)
					{
						for(int w2 = 0; w2 < PANEL_SIZE; w2++)
						{
							/*if(g_CheckPanelW[h2][w2] == 1)
							{*/
								/*g_DeletePanelW[h2][w2] = 1; // チェックしたブロック→消える*/
							if(g_DeletePanelW[h2][w2] == 1){
								
								g_Panel[h2][w2] = BLOCK_NO;
								
							}
							/*}*/
						}
					}
				}
				
            // 次の処理に備えて初期化
            /* ZeroMemory(g_CheckPanelW, sizeof(g_CheckPanelW));*/
			/*ZeroMemory(g_DeletePanelW, sizeof(g_DeletePanelW));*/
			for(int h = 0; h < PANEL_SIZE; h++)
			{
				for(int w = 0; w < PANEL_SIZE; w++)
				{
					g_DeletePanelW[h][w]=0;
				}
			}
            g_DelCountW = 0;
			}
		}
	}
	for( h = 0; h < PANEL_SIZE; h++)
	{
		for( w = 0; w < PANEL_SIZE; w++)
		{
			if(g_DeletePanelH[h][w] == 0)
			{ // まだ消えていないブロックなら…
            
				SearchDelBlockH(h, w); // 再帰ルーチン(縦)スタート

				if(g_DelCountH >= DEL_MIN)
				{ // 消えるなら…
					for(int h2 = 0; h2 < PANEL_SIZE; h2++)
					{
						for(int w2 = 0; w2 < PANEL_SIZE; w2++)
						{
							/*if(g_CheckPanelH[h2][w2] == 1)
							{*/
								// これのフラグが消されていない可能性がある！
								/*g_DeletePanelH[h2][w2] = 1; // チェックしたブロック→消える*/
							if(g_DeletePanelH[h2][w2] == 1){
								
								g_Panel[h2][w2] = BLOCK_NO;
								
							}
							/*}*/
						}
					}
				}
				

            // 次の処理に備えて初期化
           /* ZeroMemory(g_CheckPanelH, sizeof(g_CheckPanelH));*/
			/*ZeroMemory(g_DeletePanelH, sizeof(g_DeletePanelH));*/
			for(int h = 0; h < PANEL_SIZE; h++)
			{
				for(int w = 0; w < PANEL_SIZE; w++)
				{
					g_DeletePanelH[h][w]=0;
				}
			}
            g_DelCountH = 0;
			
			}
		}
	}
}

//==============================================================================================
// 再帰ルーチン(横)
//==============================================================================================
void SearchDelBlockW(int h, int w){

   /* g_CheckPanelW[h][w] = 1; // チェックしました。*/
	g_DeletePanelW[h][w] = 1;
    g_DelCountW++;
    
    /*if(w + 1 < PANEL_SIZE){ //→
        if(g_CheckPanelW[h][w + 1] == 0 && g_Block[g_Panel[h][w]] == g_Block[g_Panel[h][w + 1]]){
			SearchDelBlockW(h, w + 1);
		}
    }
    
    if(w - 1 >= 0){ //←
        if(g_CheckPanelW[h][w - 1] == 0 && g_Block[g_Panel[h][w]] == g_Block[g_Panel[h][w - 1]]){
			SearchDelBlockW(h, w - 1);
		}
    }*/
	if(w + 1 < PANEL_SIZE){ //→
        if(g_DeletePanelW[h][w + 1] == 0 && g_Block[g_Panel[h][w]] == g_Block[g_Panel[h][w + 1]]){
			SearchDelBlockW(h, w + 1);
		}
    }
    
    if(w - 1 >= 0){ //←
        if(g_DeletePanelW[h][w - 1] == 0 && g_Block[g_Panel[h][w]] == g_Block[g_Panel[h][w - 1]]){
			SearchDelBlockW(h, w - 1);
		}
    }
}

//==============================================================================================
// 再帰ルーチン(縦)
//==============================================================================================
void SearchDelBlockH(int h, int w){

    /*g_CheckPanelH[h][w] = 1; // チェックしました。*/
	g_DeletePanelH[h][w] = 1;
    g_DelCountH++;

    /*if(h + 1 < PANEL_SIZE){ //↓
        if(g_CheckPanelH[h + 1][w] == 0 && g_Block[g_Panel[h][w]] == g_Block[g_Panel[h + 1][w]]){
			SearchDelBlockH(h + 1, w);
		}
    }
    
    if(h - 1 >= 0){ //↑
        if(g_CheckPanelH[h - 1][w] == 0 && g_Block[g_Panel[h][w]] == g_Block[g_Panel[h - 1][w]]){
			SearchDelBlockH(h - 1, w);
		}
    }*/
	if(h + 1 < PANEL_SIZE){ //↓
        if(g_DeletePanelH[h + 1][w] == 0 && g_Block[g_Panel[h][w]] == g_Block[g_Panel[h + 1][w]]){
			SearchDelBlockH(h + 1, w);
		}
    }
    
    if(h - 1 >= 0){ //↑
        if(g_DeletePanelH[h - 1][w] == 0 && g_Block[g_Panel[h][w]] == g_Block[g_Panel[h - 1][w]]){
			SearchDelBlockH(h - 1, w);
		}
    }
}
int FallBlock(void)
{
    int h,w,iy,n=0;
	int state = 0;
    for(w=0;w<PANEL_SIZE;w++)
	{ // 列方向
        for(h=PANEL_SIZE;h>=0;h--)
		{      // 下から調べる
            if(g_Panel[h][w]==BLOCK_NO)
			{    // 空のマスが見つかれば上にある(かもしれない)
				if(h==0&&g_Panel[h][w]==BLOCK_NO)
				{
					g_Panel[h][w]= GetRand(4);
				}
                for(iy=h-1;iy>=0 && g_Panel[iy][w]==BLOCK_NO;iy--);    // 空のマスを読み飛ばす

                if(iy<=0) break;                               // 上にブロックが無い(次の列へ)

                n++;      // 落とした列数 （これいるのか？）
			
                for(iy=h;iy>=0;iy--)
				{       // １マスだけ落とす
                    if(iy>=1) 
					{
						g_Panel[iy][w]=g_Panel[iy-1][w];
					}
					
                    else
					g_Panel[iy][w]= GetRand(4);
					
					
                }
                break;     // 次の列へ
            }
        }
    }
	
    return n;//（これいるのか？）
}


void DrawStage(void){

	int h,w;

	SearchDelBlock();
	FallBlock();

	for( h = 0; h < PANEL_SIZE ; h++)
	{
		for( w = 0; w < PANEL_SIZE; w++)
		{
			SetDrawBlendMode( DX_BLENDMODE_ALPHA,  224 );
			DrawGraph( (w)*32, (h)*32 , g_Block[g_Panel[h][w]], TRUE );
			SetDrawBlendMode( DX_BLENDMODE_NOBLEND,  0 );
			
		}
	}
	
}