#define _WIN32_WINNT	0x0400		/// for WM_MOUSEWHEEL
#define _WIN32_WINDOWS	0x0401		/// for WM_MOUSEWHEEL

/* winuser.h ( windows.h が include する)

#if (_WIN32_WINNT >= 0x0400) || (_WIN32_WINDOWS > 0x0400)
#define WM_MOUSEWHEEL                   0x020A

*/

#include<windows.h>
#include<time.h>
#include<math.h>
#include"resource.h"
#include"WaveResource.h"
#include"MidiResource.h"

// winmm.lib をリンクする
#pragma comment(lib,"winmm")

/// 曲を変える(かもしれない)時にメインスレッドに送る
/// (MCIはオープンしたスレッド以外からは操作できない)
#define WM_CHANGE_BGM WM_APP

/// ゲームオーバーした時にメインスレッドに送る
/// (WAVE & MIDI 再生を要求)
#define WM_GAMEOVER WM_APP+1

/// 入力キー取得ウィンドウを閉じる時にキーコンフィグダイアログに送るメッセージ
/// ( wParam , lParam には WM_KEYDOWN のそれが入る)
#define WM_INPUT WM_APP+2

// メインスレッドにミューテックスの所有権取得を要求するメッセージ
#define WM_MUTEX WM_APP+3
// ミューテックスオブジェクトの名前
#define MUTEX_NAME "MutexObject of TOKOPUYO"

#define OJAMA	0x007f7f7f		/// おじゃまぷよ
#define KATA	0x00ffffff		/// 固ぷよ

// ピースの横と縦のマス数
#define PW	3
#define PH	3

// ゲームフィールドの横と縦のマス数
#define FW	 6
#define FH	13		/// 最上段は表示しない

// マスのピクセル数
#define CW	30
#define CH	30

/* MovePiece 関数の引数 */
#define MOVE_LEFT	2
#define MOVE_RIGHT	4
#define MOVE_DOWN	8

/// TurnPiece 関数の引数
#define TURN_LEFT	16
#define TURN_RIGHT	32
#define TURN_OVER	64		/// 反転

DWORD Field[FW][FH]={0};		/// ゲームフィールドの色
DWORD Piece[PW][PH]={0};		/// 移動中のピースの色
POINT Pos={0,0};				/* 移動中のピースの位置 */
DWORD Next[PW][PH]={0};			/// 次のピースの色

DWORD Add=0;					/// 新しく獲得した点数
DWORD Score=0;					// 獲得点数の合計
DWORD PlayTime=0;				// プレイ時間
BOOL GameOver=FALSE;			// TRUE になるのはゲームオーバーからニューゲーム開始前まで
char State[32]="いっきま〜す";	/// 状態明示文字列

/// プレイヤー設定項目
DWORD Ojama=0;		/// おじゃまぷよの有無と種類
DWORD OjaMax=4;		/// おじゃまぷよが一度に出現する最大数
DWORD OjaRand=10;	/// おじゃまぷよの頻度
DWORD Variety=5;	/// 何種類の色ぷよが出現するのか？
DWORD Delete=4;		/// いくつ以上色ぷよが隣接すれば消えるのか？
DWORD Speed=800;	/// 初期落下スピード

typedef enum{TL=0,TR,TO,ML,MR,MD,PA,NG,KC,KEYNUM}KEY;		/// キー操作定数

/// 操作キー
WPARAM Key[KEYNUM]={'A','F',VK_SPACE,VK_LEFT,VK_RIGHT,VK_DOWN,VK_ESCAPE,VK_RETURN,VK_F1};
BOOL MouseControl=TRUE;		/// マウスコントロールの自動(TRUE) or 無効(FALSE)

HINSTANCE hInst;	/// インスタンスハンドル
HFONT hFont;		/// フォントハンドル

/// WAVE
HWAVEOUT hWaveOut[9];
WAVEFORMATEX wfe[9];
WAVEHDR whdr[9];

/// MIDI
const enum{SETUP=0,PLAY,PINCH};
MCI_OPEN_PARMS Mop[3];
MCI_PLAY_PARMS Mpp;

/* Piece[][] 内のぷよの最上部の位置を返す */
int GetPieceTop(void)
{
	for(int y=0;y<PH;y++){
		for(int x=0;x<PW;x++){
			if(Piece[x][y]) return y;
		}
	}
	return -1;		/// error
}

/* Piece[][]　内のぷよの最下部の位置を返す */
int GetPieceBottom(void)
{
	for(int y=PH-1;y>=0;y--){
		for(int x=0;x<PW;x++){
			if(Piece[x][y]) return y;
		}
	}
	return -1;		/// error
}

/* Piece[][]　内のぷよの左端の位置を返す */
int GetPieceLeft(void)
{
	for(int x=0;x<PW;x++){
		for(int y=0;y<PH;y++){
			if(Piece[x][y]) return x;
		}
	}
	return -1;		/// error
}

/* Piece[][]　内のぷよの右端の位置を返す */
int GetPieceRight(void)
{
	for(int x=PW-1;x>=0;x--){
		for(int y=0;y<PH;y++){
			if(Piece[x][y]) return x;
		}
	}
	return -1;		/// error
}

/* ピースの移動判定 */
// move：移動したい方向
// 戻り値：TURE(移動した) or FALSE(移動不可)
BOOL MovePiece(int move)
{
	int x,y,left,right,bottom;
	switch(move){
		case MOVE_LEFT:
			left=GetPieceLeft();
			if((Pos.x)+left <= 0) return FALSE;

			for(y=0;y<PH;y++){		// ↓(Pos.x)+x-1>=0 , (Pos.y)+y>=0
				for(x=0;x<PW;x++){	// は添字の有効性を調べている
					if(Piece[x][y] && (Pos.x)+x-1>=0 && (Pos.y)+y>=0
						&& Field[(Pos.x)+x-1][(Pos.y)+y]) return FALSE;
				}		// ↑一つ左にぷよがいる
			}
			Pos.x--;
			return TRUE;
		case MOVE_RIGHT:
            right=GetPieceRight();
			if((Pos.x)+right >= FW-1) return FALSE;

			for(y=0;y<PH;y++){		// ↓(Pos.x)+x+1<FW , (Pos.y)+y>=0
				for(x=0;x<PW;x++){	// は添字の有効性を調べている
					if(Piece[x][y] && (Pos.x)+x+1<FW && (Pos.y)+y>=0
						&& Field[(Pos.x)+x+1][(Pos.y)+y]) return FALSE;
				}		// ↑一つ右にぷよがいる
			}
			Pos.x++;
			return TRUE;
		case MOVE_DOWN:
            bottom=GetPieceBottom();
			if((Pos.y)+bottom >= FH-1) return FALSE;

			for(y=0;y<PH;y++){		// ↓(Pos.y)+y+1>=0 , (Pos.y)+y+1<FH
				for(x=0;x<PW;x++){	// は添字の有効性を調べている
					if(Piece[x][y] && (Pos.y)+y+1>=0 && (Pos.y)+y+1<FH
						&& Field[(Pos.x)+x][(Pos.y)+y+1]) return FALSE;
				}		// ↑一つ下にぷよがいる
			}
			Pos.y++;
			return TRUE;
	}
	return FALSE;
}

/* ピースを回転させる */
/// turn：回転したい方向
// 戻り値：TURE(回転した) or FALSE(回転不可)
BOOL TurnPiece(int turn)
{
	DWORD pTurn[PW][PH]={0};
	enum{TOP,LEFT,BOTTOM,RIGHT}vec;		/// ぷよの向き

	/// 現在のぷよの向きを調べる
	if(Piece[1][0]) vec=TOP;		/// ぷよの配置は４状態しかない
	else if(Piece[0][1]) vec=LEFT;
	else if(Piece[1][2]) vec=BOTTOM;
	else if(Piece[2][1]) vec=RIGHT;
	else return FALSE;

	/* 回転したピースを生成する */
	pTurn[1][1]=Piece[1][1];		/// 中心は不動
	switch(turn){
		case TURN_LEFT:
			switch(vec){
				case TOP: pTurn[0][1]=Piece[1][0]; break;
				case LEFT: pTurn[1][2]=Piece[0][1]; break;
				case BOTTOM: pTurn[2][1]=Piece[1][2]; break;
				case RIGHT: pTurn[1][0]=Piece[2][1]; break;
			}
			break;
		case TURN_RIGHT:
			switch(vec){
				case TOP: pTurn[2][1]=Piece[1][0]; break;
				case RIGHT: pTurn[1][2]=Piece[2][1]; break;
				case BOTTOM: pTurn[0][1]=Piece[1][2]; break;
				case LEFT: pTurn[1][0]=Piece[0][1]; break;
			}
			break;
		case TURN_OVER:
			switch(vec){	/// 既に Piece[1][1] は pTurn[1][1] にコピーされている
				case TOP: Piece[1][1]=Piece[1][0]; Piece[1][0]=pTurn[1][1]; break;
				case BOTTOM: Piece[1][1]=Piece[1][2]; Piece[1][2]=pTurn[1][1]; break;
				case LEFT: Piece[1][1]=Piece[0][1]; Piece[0][1]=pTurn[1][1]; break;
				case RIGHT: Piece[1][1]=Piece[2][1]; Piece[2][1]=pTurn[1][1]; break;
			}
			return TRUE;
	}
	/* 回転可能かどうかを調べる */
	int x,y,ix,iy;
	for(y=0;y<PH;y++){
		for(x=0;x<PW;x++){
			if(pTurn[x][y]){
				ix=(Pos.x)+x; iy=(Pos.y)+y;		// 既にぷよがいる↓
				if(ix<0 || ix>=FW || iy>=FH || (iy>=0 && Field[ix][iy])) return FALSE;
				// iy>=0 は添字の有効性を調べている↑
			}
		}
	}
	/// 回転可能
	for(y=0;y<PH;y++){
		for(x=0;x<PW;x++){
			Piece[x][y]=pTurn[x][y];
		}
	}
	return TRUE;
}

/// 自分に隣接している同色ぷよの個数を調べる(探索後に消す)
/// x：現在のx座標 , y：現在のy座標 , *n：個数
void Count(int x,int y,DWORD *n)
{
	DWORD c=Field[x][y];		/// 自分の色
	Field[x][y]=0; (*n)++;

	if(x+1<FW && Field[x+1][y]==c) Count(x+1,y,n);
	if(y+1<FH && Field[x][y+1]==c) Count(x,y+1,n);
	if(x-1>=0 && Field[x-1][y]==c) Count(x-1,y,n);
	if(y-1>=0 && Field[x][y-1]==c) Count(x,y-1,n);
}

/// ぷよを消す(Count関数の応用)
/// f[FW][FH]：ゲームフィールドの色
/// x：現在のx座標 , y：現在のy座標
void Vanish(DWORD f[FW][FH],int x,int y)
{
	DWORD c=f[x][y];		/// 自分の色

	f[x][y]=0;		/// 色ぷよを消す
	/// 固ぷよ→おじゃまぷよ or おじゃまぷよ→消す
	if(x+1<FW){
		if(f[x+1][y]==KATA) f[x+1][y]=OJAMA;
		else if(f[x+1][y]==OJAMA) f[x+1][y]=0;
	}
	if(y+1<FH){
		if(f[x][y+1]==KATA) f[x][y+1]=OJAMA;
		else if(f[x][y+1]==OJAMA) f[x][y+1]=0;
	}
	if(x-1>=0){
		if(f[x-1][y]==KATA) f[x-1][y]=OJAMA;
		else if(f[x-1][y]==OJAMA) f[x-1][y]=0;
	}
	if(y-1>=0){
		if(f[x][y-1]==KATA) f[x][y-1]=OJAMA;
		else if(f[x][y-1]==OJAMA) f[x][y-1]=0;
	}

	if(x+1<FW && f[x+1][y]==c) Vanish(f,x+1,y);
	if(y+1<FH && f[x][y+1]==c) Vanish(f,x,y+1);
	if(x-1>=0 && f[x-1][y]==c) Vanish(f,x-1,y);
	if(y-1>=0 && f[x][y-1]==c) Vanish(f,x,y-1);
}

/// ゲームフィールドの色をコピーする
/// to[FW][FH]：コピー先の配列 , from[FW][FH]：コピー元の配列
void CopyField(DWORD to[FW][FH],DWORD from[FW][FH])
{
	for(int y=0;y<FH;y++){
		for(int x=0;x<FW;x++){
            to[x][y]=from[x][y];
		}
	}
}

/// 四方に Delete 以上隣接している色ぷよを消す
/// (おじゃま＆固ぷよについてはVanish関数が処理)
/// 戻り値：消去した色ぷよの数
int DeletePuyo(void)
{
	int x,y;
	DWORD f[FW][FH],n,d=0;

	CopyField(f,Field);		/// f[][] に完成状態を作っていく( Field[][] は作業用)
	for(y=0;y<FH;y++){
		for(x=0;x<FW;x++){
			n=Field[x][y];
			if(n && n!=OJAMA && n!=KATA){	/// 色ぷよだけ
				n=0; Count(x,y,&n);			/// いくつ繋がっているか？
				if(n>=Delete){Vanish(f,x,y); d+=n;}		/// 消去した色ぷよの数をカウント
			}				/// ↑ぷよを消す
		}
	}
	CopyField(Field,f);		/// 処理結果を反映させる
	return d;
}

/// 消去する時のエフェクトを Field[][] の最上位バイトに指定する
/// werrrrrr
/// w：Weepフラグ
/// e：Expansionフラグ
/// r：膨張量(eが1の時だけ使う)

/// 泣き顔を表示させる
/// sub[FW][FH]：これから消えるぷよの集合
void Weep(DWORD sub[FW][FH])
{
	for(int y=0;y<FH;y++){
		for(int x=0;x<FW;x++){
			if(sub[x][y]) Field[x][y]=sub[x][y] | (1<<31);		/// 最上位ビットを使う
		}
	}
}

/// 消す(明滅に利用)
/// sub[FW][FH]：これから消えるぷよの集合
void Invisible(DWORD sub[FW][FH])
{
	for(int y=0;y<FH;y++){
		for(int x=0;x<FW;x++){
			if(sub[x][y]) Field[x][y]=0;
		}
	}
}

/// 徐々に膨張させる(外枠だけ描画する)
/// sub[FW][FH]：これから消えるぷよの集合
/// hWnd：ウィンドウのハンドル
void Expansion(DWORD sub[FW][FH],HWND hWnd)
{
	for(int r=0;r<5;r++){		/// 0 <= r <= 63
		for(int y=0;y<FH;y++){
			for(int x=0;x<FW;x++){
				if(sub[x][y]) Field[x][y]=sub[x][y] | (1<<30) | (r<<24);
			}										///↑フラグ　↑膨張量
		}
		InvalidateRect(hWnd,NULL,FALSE); Sleep(100);
	}
}

/// ぷよが消える時に様々な効果を適用する
/// hWnd：ウィンドウのハンドル
/// 戻り値：消去した色ぷよの数(DeletePuyo関数の戻り値)
int DeletePuyoEffect(HWND hWnd)
{
	DWORD sub[FW][FH];
	static int rensa=1;		/// この関数は連鎖が終了するまで何度も呼び出される

	CopyField(sub,Field);
	int d=DeletePuyo();
	if(d==0){rensa=1; return 0;}	/// ぷよは消えなかった(連鎖終了)

	/// ぷよが消えた
	int magic=(rensa>7)?7:rensa;
	waveOutWrite(hWaveOut[magic],&whdr[magic],sizeof(WAVEHDR));

	Add=d*40*(DWORD)pow(2,rensa-1); Score+=Add;
	rensa++;

	for(int y=0;y<FH;y++){
		for(int x=0;x<FW;x++){
			sub[x][y]-=Field[x][y];
		}
	}

	Weep(sub);
	InvalidateRect(hWnd,NULL,FALSE); Sleep(300);	/// 泣き顔を表示
	Invisible(sub);
	InvalidateRect(hWnd,NULL,FALSE); Sleep(100);	/// 消えた状態を表示
	Weep(sub);
	InvalidateRect(hWnd,NULL,FALSE); Sleep(100);	/// 泣き顔を表示
	Invisible(sub);		/// Weepフラグ消去

	Expansion(sub,hWnd);	/// 徐々に膨張させる
	Invisible(sub);			/// 本当に消す

	return d;
}

/// 曲を状況に応じて変える
/// stop：TRUE(曲を止める) or FALSE(曲を変える)
void ChangeBGM(BOOL stop)
{
	const int pinch=54;
	static int i=0;

	if(stop){		/// 曲を止めて静的変数を再初期化
		if(i<pinch){
			mciSendCommand(Mop[PLAY].wDeviceID,MCI_STOP,0,0);
			mciSendCommand(Mop[PLAY].wDeviceID,MCI_SEEK,MCI_SEEK_TO_START,0);
		}else{
			mciSendCommand(Mop[PINCH].wDeviceID,MCI_STOP,0,0);
			mciSendCommand(Mop[PINCH].wDeviceID,MCI_SEEK,MCI_SEEK_TO_START,0);
		}
		i=0; return;
	}

	int n=0;
	for(int y=0;y<FH;y++){
		for(int x=0;x<FW;x++){
			if(Field[x][y]) n++;
		}
	}
	if(i<pinch && n>=pinch){				/// 通常からピンチ
		mciSendCommand(Mop[PLAY].wDeviceID,MCI_STOP,0,0);
		mciSendCommand(Mop[PLAY].wDeviceID,MCI_SEEK,MCI_SEEK_TO_START,0);

		mciSendCommand(Mop[PINCH].wDeviceID,MCI_PLAY,MCI_NOTIFY,(DWORD_PTR)&Mpp);
	}else if(i>=pinch && n<pinch){		/// ピンチから通常
		mciSendCommand(Mop[PINCH].wDeviceID,MCI_STOP,0,0);
		mciSendCommand(Mop[PINCH].wDeviceID,MCI_SEEK,MCI_SEEK_TO_START,0);

		mciSendCommand(Mop[PLAY].wDeviceID,MCI_PLAY,MCI_NOTIFY,(DWORD_PTR)&Mpp);
	}
	i=n;
}

/// 浮いているぷよを１マスだけ落とす
/// 戻り値：ぷよを落とした列数
int FallPuyo(void)
{
	int x,y,iy,n=0;
	for(x=0;x<FW;x++){		/// 列方向
		for(y=FH-1;y>=0;y--){		/// 下から調べる
			if(Field[x][y]==0){		/// 空のマスが見つかれば上にある(かもしれない)ぷよを探す
				for(iy=y-1;iy>=0 && Field[x][iy]==0;iy--);	/// 空のマスを読み飛ばす
				if(iy<0) break;								/// 上にぷよが無い(次の列へ)
				n++;		/// ぷよを落とした列数
				for(iy=y;iy>=0;iy--){		/// ぷよを１マスだけ落とす
					if(iy-1>=0) Field[x][iy]=Field[x][iy-1];
					else Field[x][iy]=0;	/* 0 行より上はないので 0 で埋める */
				}
				break;		/// 次の列へ
			}
		}
	}
	return n;
}

/// 浮いているを１マスずつ落とす
/// hWnd：ウィンドウのハンドル
/// 戻り値：待機した合計時間
DWORD FallPuyoAuto(HWND hWnd)
{
	for(DWORD sleep=0;FallPuyo();sleep+=100){		/// 浮いているぷよが無くなるまで続ける
        InvalidateRect(hWnd,NULL,FALSE); Sleep(100);
	}
	return sleep;
}

/// おじゃまぷよをランダムに作って落とす
/// hWnd：ウィンドウのハンドル
/// 戻り値：待機した合計時間
DWORD FallOjama(HWND hWnd)
{
	if(Ojama==0) return 0;
	if(rand()%OjaRand) return 0;		/// ランダムに生成

	int r=rand()%OjaMax+1;		/// 作りたいおじゃまぷよの数
	int fx[FW],n,a,b;
	DWORD sleep=0;

	while(1){
		n=0;
		for(int x=0;x<FW;x++){
			if(Field[x][0]==0) fx[n++]=x;		/// 最上段にぷよが無いマスのx座標と個数を記録
		}
		if(n==0) return sleep;		/// 置ける場所がない
		if(r<n){		/// 作りたい数 ＜ 置ける場所の数
			for(x=0;x<n;x++){a=fx[x]; fx[x]=fx[b=rand()%n]; fx[b]=a;}		/// シャッフル
			for(x=0;x<r;x++) Field[fx[x]][0]=(Ojama==1)?OJAMA:(Ojama==3)?KATA:(rand()%3)?OJAMA:KATA;
			sleep+=FallPuyoAuto(hWnd); return sleep;						/// ↑Ojama==2
		}else{			/// とりあえず置けるだけ置く(作りたい数 ＞ 置ける場所の数)
			for(x=0;x<n;x++) Field[fx[x]][0]=(Ojama==1)?OJAMA:(Ojama==3)?KATA:(rand()%3)?OJAMA:KATA;
			FallPuyo(); InvalidateRect(hWnd,NULL,FALSE); Sleep(100);
			r-=n; sleep+=100;		/// 一段落として残っているおじゃまぷよを置く
		}							/// (全て置くか置く場所が無くなるまで)
	}
}

// 次のピースを作る
void CreateNextPiece(void)
{
	for(int y=0;y<PH;y++){
		for(int x=0;x<PW;x++){
			Next[x][y]=0;
		}
	}
	for(y=0;y<=1;y++){
		switch(rand()%Variety){
			case 0: Next[1][y]=0x000000ff; continue;
			case 1: Next[1][y]=0x0000ff00; continue;
			case 2: Next[1][y]=0x0000ffff; continue;
			case 3: Next[1][y]=0x00ff0000; continue;
			case 4: Next[1][y]=0x00ff00ff; continue;
			case 5: Next[1][y]=0x00ffff00; continue;
		}	/// 0x007f7f7f(おじゃまぷよ) 0x00ffffff(固ぷよ)
	}
}

/// 次のピースを現在のピースにコピー
/// hWnd：ウィンドウのハンドル
/// start：ゲーム開始から最初の呼び出しか否か
void NewPiece(HWND hWnd,BOOL start)
{
	/// ウィンドウがアクティブになるまで待つ
	while(hWnd!=GetForegroundWindow()){Sleep(50);}

	if(start){
		mciSendCommand(Mop[PLAY].wDeviceID,MCI_PLAY,MCI_NOTIFY,(DWORD_PTR)&Mpp);
		waveOutWrite(hWaveOut[0],&whdr[0],sizeof(WAVEHDR));
		CreateNextPiece();
	}

	for(int y=0;y<PH;y++){
		for(int x=0;x<PW;x++){
			Piece[x][y]=Next[x][y];
		}
	}
	Pos.x=1; Pos.y=0;

	CreateNextPiece();		/// 次のピースをあらかじめ作っておく

	if(!MouseControl) return;
	/// マウスカーソルの自動位置調節
	POINT pt;
	RECT client;
	GetCursorPos(&pt);
	ScreenToClient(hWnd,&pt);
	GetClientRect(hWnd,&client);
	if(pt.x>=0 && pt.x<client.right && pt.y>=0 && pt.y<client.bottom){
		pt.x=(Pos.x+2)*CW+CW/2; pt.y=(Pos.y+1)*CH+CH/2;
		ClientToScreen(hWnd,&pt);
		SetCursorPos(pt.x,pt.y);		/// クライアント領域にある時だけカーソルを移動させる
	}
}

/// 位置情報に従ってピースをフィールドにコピーして消す
void PieceToField(void)
{
	for(int y=0;y<PH;y++){
		for(int x=0;x<PW;x++){		// ↓(Pos.y)+y>=0 は添字の有効性を調べている
			if(Piece[x][y] && (Pos.y)+y>=0){	/// 最上段より上にはみ出す可能性を考慮
				Field[(Pos.x)+x][(Pos.y)+y]=Piece[x][y];
			}
			Piece[x][y]=0;
		}
	}
}

// 再初期化する
// hWnd：ウィンドウのハンドル
void ReInitialize(HWND hWnd)
{
	for(int y=0;y<FH;y++){
		for(int x=0;x<FW;x++){
			Field[x][y]=0;
		}
	}
	Score=0;
	PlayTime=0;
	GameOver=FALSE;
	wsprintf(State,"いっきま〜す");

	NewPiece(hWnd,TRUE);	// Piece[][] , Pos , Next[][] が NewPiece() 関数で初期化される
}

/// 描画に使うマクロ
#define BGR(color)	  (color & 0x00ffffff)
#define WEEP(field)	( (field & 0x80000000)>>31 )
#define EXP(field)	( (field & 0x40000000)>>30 )
#define RAD(field)	( (field & 0x3f000000)>>24 )

// 描画する
// hdc：デバイスコンテキストのハンドル
void Paint(HDC hdc)
{
	int x,y,ptx,pty,r;
	HPEN hPen,hOldPen;
	HBRUSH hBrush,hOldBrush;

	// ゲームフィールドのぷよ
	for(y=1;y<FH;y++){		/// 最上段は表示しない
		for(x=0;x<FW;x++){
			if(Field[x][y] && !EXP(Field[x][y])){
				ptx=(x+1)*CW; pty=y*CH;

				hPen=CreatePen(PS_SOLID,1,BGR(Field[x][y])); hOldPen=(HPEN)SelectObject(hdc,hPen);
				hBrush=CreateSolidBrush(BGR(Field[x][y])); hOldBrush=(HBRUSH)SelectObject(hdc,hBrush);
				Ellipse(hdc,ptx-1,pty-1,ptx+CW+1,pty+CH+1);		/// マスより１ピクセル大きく描く
				SelectObject(hdc,hOldPen); DeleteObject(hPen);
				SelectObject(hdc,hOldBrush); DeleteObject(hBrush);

				SelectObject(hdc,GetStockObject(BLACK_PEN));
				SelectObject(hdc,GetStockObject(WHITE_BRUSH));
				if(WEEP(Field[x][y])){
					Ellipse(hdc,ptx+3,pty+10,ptx+15,pty+22);		/// 左白目
					Ellipse(hdc,ptx+16,pty+10,ptx+28,pty+22);		/// 右白目
				}else{
					Ellipse(hdc,ptx+5,pty+10,ptx+15,pty+21);		/// 左白目
					Ellipse(hdc,ptx+16,pty+10,ptx+26,pty+21);		/// 右白目
				}

				SelectObject(hdc,GetStockObject(BLACK_BRUSH));
				Ellipse(hdc,ptx+10,pty+13,ptx+15,pty+18);		/// 左黒目
				Ellipse(hdc,ptx+16,pty+13,ptx+21,pty+18);		/// 右黒目
			}
		}
	}
	/// 膨張するぷよ
	for(y=1;y<FH;y++){		/// 最上段は表示しない
		for(x=0;x<FW;x++){
			if(EXP(Field[x][y])){
				hPen=CreatePen(PS_SOLID,1,BGR(Field[x][y])); hOldPen=(HPEN)SelectObject(hdc,hPen);
				SelectObject(hdc,GetStockObject(NULL_BRUSH));
				ptx=(x+1)*CW; pty=y*CH; r=RAD(Field[x][y]);		/// r だけ膨張
				Ellipse(hdc,ptx-1-r,pty-1-r,ptx+CW+1+r,pty+CH+1+r);
				SelectObject(hdc,hOldPen); DeleteObject(hPen);
			}
		}
	}
	// 移動中のピース
	for(y=0;y<PH;y++){
		if((Pos.y)+y < 1) continue;		/// ゲームフィールドの枠より上は描かない
		for(x=0;x<PW;x++){
			if(Piece[x][y]){
				ptx=((Pos.x)+1+x)*CW; pty=((Pos.y)+y)*CH;

				hPen=CreatePen(PS_SOLID,1,Piece[x][y]); hOldPen=(HPEN)SelectObject(hdc,hPen);
				hBrush=CreateSolidBrush(Piece[x][y]); hOldBrush=(HBRUSH)SelectObject(hdc,hBrush);
				Ellipse(hdc,ptx-1,pty-1,ptx+CW+1,pty+CH+1);		/// マスより１ピクセル大きく描く
				SelectObject(hdc,hOldPen); DeleteObject(hPen);
				SelectObject(hdc,hOldBrush); DeleteObject(hBrush);

				SelectObject(hdc,GetStockObject(BLACK_PEN));
				SelectObject(hdc,GetStockObject(WHITE_BRUSH));
				Ellipse(hdc,ptx+5,pty+10,ptx+15,pty+21);		/// 左白目
				Ellipse(hdc,ptx+16,pty+10,ptx+26,pty+21);		/// 右白目
				
				SelectObject(hdc,GetStockObject(BLACK_BRUSH));
				Ellipse(hdc,ptx+10,pty+13,ptx+15,pty+18);		/// 左黒目
				Ellipse(hdc,ptx+16,pty+13,ptx+21,pty+18);		/// 右黒目
			}
		}
	}
	// 次のピース
	for(y=0;y<PH;y++){
		for(x=0;x<PW;x++){
			if(Next[x][y]){
				ptx=(FW+2+x)*CW; pty=(y+1)*CH;

				hPen=CreatePen(PS_SOLID,1,Next[x][y]); hOldPen=(HPEN)SelectObject(hdc,hPen);
				hBrush=CreateSolidBrush(Next[x][y]); hOldBrush=(HBRUSH)SelectObject(hdc,hBrush);
				Ellipse(hdc,ptx-1,pty-1,ptx+CW+1,pty+CH+1);
				SelectObject(hdc,hOldPen); DeleteObject(hPen);
				SelectObject(hdc,hOldBrush); DeleteObject(hBrush);

				SelectObject(hdc,GetStockObject(BLACK_PEN));
				SelectObject(hdc,GetStockObject(WHITE_BRUSH));
				Ellipse(hdc,ptx+5,pty+10,ptx+15,pty+21);		/// 左白目
				Ellipse(hdc,ptx+16,pty+10,ptx+26,pty+21);		/// 右白目
				
				SelectObject(hdc,GetStockObject(BLACK_BRUSH));
				Ellipse(hdc,ptx+10,pty+13,ptx+15,pty+18);		/// 左黒目
				Ellipse(hdc,ptx+16,pty+13,ptx+21,pty+18);		/// 右黒目
			}
		}
	}
	/// 枠
	///SelectObject(hdc,GetStockObject(WHITE_PEN));
	///SelectObject(hdc,GetStockObject(NULL_BRUSH));
	///Rectangle(hdc,CW-1,CH-1,(FW+1)*CW+1,FH*CH+1);		/// ゲームフィールドの枠
	///Rectangle(hdc,(FW+2)*CW-1,CH-1,(FW+2+PW)*CW+1,(PH+1)*CH+1);		// 次のピースの枠

	char buf[32];
	SetTextColor(hdc,RGB(255,255,255)); SetBkMode(hdc,TRANSPARENT);
	x=245; y=155;
	// プレイ時間
	wsprintf(buf,"PLAY TIME"); TextOut(hdc,x,y,buf,(int)strlen(buf));
	wsprintf(buf,"%02d:%02d:%03d",(PlayTime/1000)/60,(PlayTime/1000)%60,PlayTime%1000);
	TextOut(hdc,x,y+24,buf,(int)strlen(buf));
	// 獲得点数
	wsprintf(buf,"SCORE"); TextOut(hdc,x,y+64,buf,(int)strlen(buf));
	wsprintf(buf,"+%d",Add); TextOut(hdc,x,y+88,buf,(int)strlen(buf));
	wsprintf(buf,"%10d",Score); TextOut(hdc,x,y+112,buf,(int)strlen(buf));
	/// 状態明示文字列
	wsprintf(buf,"-------"); TextOut(hdc,x,y+142,buf,(int)strlen(buf));
	HFONT hOldFont=(HFONT)SelectObject(hdc,hFont);
	TextOut(hdc,x,y+166,State,(int)strlen(State));
	SelectObject(hdc,hOldFont);
}

/// 各種プロシージャ
DWORD WINAPI ThreadProc(LPVOID lpParameter);
DWORD WINAPI MouseProc(LPVOID lpParameter);
LRESULT CALLBACK RuleDlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam);
LRESULT CALLBACK KeyDlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam);
LRESULT CALLBACK InputWindowProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam);

LRESULT CALLBACK WindowProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
	HDC hdc;
	PAINTSTRUCT ps;
	BOOL paint;
	DWORD dwID;
	HBITMAP hBitmap;
	int i;
	static BITMAP bitmap;
	static HDC hBackDC,hMemDC;
	static HANDLE hThread=NULL;		// 動作制御スレッドのハンドル
	static HANDLE hMouse=NULL;		/// マウス制御スレッドのハンドル
	static HANDLE hMutex=NULL;		// ミューテックスオブジェクトのハンドル
	static BOOL suspend=FALSE;
	static DWORD befSusTime=0;
	const char WaveRscName[9][16]={"ikkimasu","m1","m2","m3","m4","m5","m6","m7","batankyu"};
	const char MidiRscName[3][16]={"setup","play","pinch"};
	static char midiFilePath[3][MAX_PATH];

	switch(uMsg) {
		case WM_CREATE:
			// 背景画像をロードする
			hBitmap=(HBITMAP)LoadImage(hInst,"haikei.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
			if(hBitmap==NULL){
				MessageBox(hWnd,"プログラムを終了します","背景画像がありません",MB_OK);
				SendMessage(hWnd,WM_DESTROY,0,0);
				return 0;
			}
			GetObject(hBitmap,sizeof(BITMAP),&bitmap);		/// 同じ大きさのメモリデバイスコンテキストを作る
			hdc=GetDC(hWnd);
			hBackDC=CreateCompatibleDC(hdc);
			SelectObject(hBackDC,hBitmap);
			DeleteObject(hBitmap);

			// メモリデバイスコンテキストを作る
			hBitmap=CreateCompatibleBitmap(hdc,bitmap.bmWidth,bitmap.bmHeight);
			hMemDC=CreateCompatibleDC(hdc);
			ReleaseDC(hWnd,hdc);
			SelectObject(hMemDC,hBitmap);
			DeleteObject(hBitmap);

			/// WAVE
			for(i=0;i<9;i++){
				waveInRsc(WaveRscName[i],&wfe[i],&whdr[i]);
				waveOutOpen(&hWaveOut[i],WAVE_MAPPER,&wfe[i],0,0,CALLBACK_NULL);
				waveOutPrepareHeader(hWaveOut[i],&whdr[i],sizeof(WAVEHDR));
			}

			srand((unsigned)time(NULL));		/// 乱数の種を蒔く

			/// MIDI
			for(i=0;i<3;i++){
				GetMidiFileName(MidiRscName[i],midiFilePath[i]);
				Mop[i].lpstrDeviceType="Sequencer";
				Mop[i].lpstrElementName=midiFilePath[i];
				mciSendCommand(NULL,MCI_OPEN,MCI_OPEN_TYPE | MCI_OPEN_ELEMENT,(DWORD_PTR)&Mop[i]);
			}	/// ↑ lpstrElementName はポインタを保存する(文字列ではない)
			Mpp.dwCallback=(DWORD_PTR)hWnd;

			/// フォントの作成
			hFont=CreateFont(14,0,0,0,
				FW_DONTCARE,FALSE,FALSE,FALSE,
				SHIFTJIS_CHARSET,OUT_DEFAULT_PRECIS,
				CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
				DEFAULT_PITCH | FF_DONTCARE,"ＭＳＰ ゴシック");

			hMutex=CreateMutex(NULL,TRUE,MUTEX_NAME);		//最初の所有者はメインスレッド

			DialogBox(hInst,"RULE",hWnd,(DLGPROC)RuleDlgProc);		/// ルール設定ダイアログ

			NewPiece(hWnd,TRUE);
			hMouse=CreateThread(NULL,0,MouseProc,hWnd,0,&dwID);		/// マウス制御スレッドを作る
			hThread=CreateThread(NULL,0,ThreadProc,hWnd,0,&dwID);	// 動作制御スレッドを作る
			return 0;
		case WM_DESTROY:
			DeleteDC(hBackDC); DeleteDC(hMemDC); DeleteObject(hFont);
			for(i=0;i<9;i++) waveClose(hWaveOut[i],&whdr[i]);
			for(i=0;i<3;i++){
				mciSendCommand(Mop[i].wDeviceID,MCI_CLOSE,0,0);
				DeleteMidiFile((char*)Mop[i].lpstrElementName);
			}
			if(hThread) CloseHandle(hThread);
			if(hMouse) CloseHandle(hMouse);
			if(hMutex) CloseHandle(hMutex);
			PostQuitMessage(0);
			return 0;
		case MM_MCINOTIFY:
			if(wParam==MCI_NOTIFY_SUCCESSFUL){
                mciSendCommand((MCIDEVICEID)lParam,MCI_SEEK,MCI_SEEK_TO_START,0);
				mciSendCommand((MCIDEVICEID)lParam,MCI_PLAY,MCI_NOTIFY,(DWORD_PTR)&Mpp);
			}
			return 0;
		case WM_CHANGE_BGM: ChangeBGM(FALSE); return 0;		/// 曲のチェック
		case WM_GAMEOVER:
			ChangeBGM(TRUE);		/// 曲を止める
			waveOutWrite(hWaveOut[8],&whdr[8],sizeof(WAVEHDR));
			return 0;
		case WM_MUTEX:
			WaitForSingleObject(hMutex,INFINITE);	// ミューテックスの所有権を取得する
			return 0;								// (動作制御スレッドを待機させる)
		case WM_PAINT:
			hdc=BeginPaint(hWnd,&ps);
			BitBlt(hMemDC,0,0,bitmap.bmWidth,bitmap.bmHeight,hBackDC,0,0,SRCCOPY);
			Paint(hMemDC);
			BitBlt(hdc,0,0,bitmap.bmWidth,bitmap.bmHeight,hMemDC,0,0,SRCCOPY);
			EndPaint(hWnd,&ps);
			return 0;
		case WM_LBUTTONDOWN: SendMessage(hWnd,WM_KEYDOWN,Key[TL],0); break;
		case WM_RBUTTONDOWN: SendMessage(hWnd,WM_KEYDOWN,Key[TR],0); break;
		case WM_MBUTTONDOWN: SendMessage(hWnd,WM_KEYDOWN,Key[TO],0); break;
		case WM_MOUSEWHEEL:		/// マウスホイールメッセージ
			if((short)HIWORD(wParam)<0) SendMessage(hWnd,WM_KEYDOWN,Key[MD],0);
			break;	/// ↑手前にホイールしていれば
		case WM_KEYDOWN:
			if(GameOver && wParam!=Key[NG]) break;
			if(suspend){
				if(wParam==Key[KC]){DialogBox(hInst,"KEY",hWnd,(DLGPROC)KeyDlgProc); break;}
				else if(wParam!=Key[PA]) break;
			}
			paint=FALSE;
			if(wParam==Key[TL]) paint=TurnPiece(TURN_LEFT);
			else if(wParam==Key[TR]) paint=TurnPiece(TURN_RIGHT);
			else if(wParam==Key[TO]) paint=TurnPiece(TURN_OVER);		/// 反転
			else if(wParam==Key[ML]) paint=MovePiece(MOVE_LEFT);
			else if(wParam==Key[MR]) paint=MovePiece(MOVE_RIGHT);
			else if(wParam==Key[MD]){paint=MovePiece(MOVE_DOWN); if(!paint) ReleaseMutex(hMutex);}
			// 現在移動中のブロックを固定させる為に動作制御スレッドの待機解除↑
			else if(wParam==Key[PA]){		// 一時停止
				if(suspend){		/// 一時停止中
					ResumeThread(hThread);
					PlayTime-=(timeGetTime()-befSusTime);
					wsprintf(State,"いっきま〜す");
					suspend=FALSE;
				}else{
					SuspendThread(hThread);
					befSusTime=timeGetTime();
					wsprintf(State,"きゅうけい......");
					suspend=TRUE;
				}
				paint=TRUE;
			}else if(wParam==Key[NG]){		// ゲームオーバーしていれば新しいゲームを始める
				if(GameOver){
					if(DialogBox(hInst,"RULE",hWnd,(DLGPROC)RuleDlgProc)==IDCANCEL) break;
					if(hMouse){CloseHandle(hMouse); hMouse=NULL;}		/// スレッドを削除
					if(hThread){CloseHandle(hThread); hThread=NULL;}	/// (スレッドは終了しても削除されない)
					ReInitialize(hWnd);		/// 再初期化
					hMouse=CreateThread(NULL,0,MouseProc,hWnd,0,&dwID);		/// マウス制御スレッドを作る
					hThread=CreateThread(NULL,0,ThreadProc,hWnd,0,&dwID);	// 動作制御スレッドを作る
					paint=TRUE;
				}
			}
			if(paint) InvalidateRect(hWnd,NULL,FALSE);
			break;
	}
	return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

// 動作制御スレッド
/// ゲーム全体の流れを制御する
// lpParameter：ウィンドウのハンドル
DWORD WINAPI ThreadProc(LPVOID lpParameter)
{
	HWND hWnd=(HWND)lpParameter;
	HANDLE hMutex=OpenMutex(MUTEX_ALL_ACCESS,FALSE,MUTEX_NAME);
	DWORD sleep=Speed;
	DWORD signal=WAIT_TIMEOUT;
	DWORD beforeTime=timeGetTime();
	DWORD progress;
	DWORD minute=0;
	int n;

	while(1){		// ↓メインスレッドからの介入がない限りタイムアウトによって待機を解除する
		signal=WaitForSingleObject(hMutex,sleep);
		progress=timeGetTime()-beforeTime;		// ←メインスレッドからの介入により
		beforeTime=timeGetTime();				// タイムアウトを待つことなく待機を解除した可能性を考慮
		PlayTime+=progress;
		minute+=progress;
		if(minute>=60*1000){		// ↓一分ごとに待機時間を減らしてゆく
			if(sleep+500>Speed && sleep>100) sleep-=100;	/// Speed-500 <= sleep <= Speed (sleep>=100)
			else sleep=Speed;		/// 元のスピードに戻す
			minute=0;
		}

		if(!MovePiece(MOVE_DOWN)){		// 現在移動中のブロックが下段に達したら以下を実行
			PieceToField();
			FallPuyoAuto(hWnd);			/// 浮いているぷよを１マスずつ落とす
			do{
				n=DeletePuyoEffect(hWnd);	/// 条件を満たせばぷよを消す
				SendMessage(hWnd,WM_CHANGE_BGM,0,0);	/// 曲のチェック
				if(n>0){
					Add=0;		/// 新しく獲得した点数を 0 に戻す
					InvalidateRect(hWnd,NULL,FALSE); Sleep(500);	/// 合計1500ms待機したことになる
					FallPuyoAuto(hWnd);		/// 落としてから100ms待機
				}
			}while(n>0);		/// 次の連鎖に移行するまで最低1600msかかる

			if(Field[2][1]){		/* ゲーム終了 */
				SendMessage(hWnd,WM_GAMEOVER,0,0);		/// WAVE & MIDI 再生

				progress=timeGetTime()-beforeTime;		/// 最終的なプレイ時間を計算する
				PlayTime+=progress; wsprintf(State,"ばたんきゅ〜");
				InvalidateRect(hWnd,NULL,FALSE);

				ReleaseMutex(hMutex);	// ミューテックスの所有権を解放
				if(hMutex) CloseHandle(hMutex);		// 全てのハンドルを閉じない限り
				SendMessage(hWnd,WM_MUTEX,0,0);		// ミューテックスは破棄されない
				GameOver=TRUE;
				return 0;		// ゲーム終了でスレッドを破棄する
			}
			FallOjama(hWnd);		/// おじゃまぷよを作って落とす(ランダムに生成)
			NewPiece(hWnd,FALSE);
		}
		InvalidateRect(hWnd,NULL,FALSE);

		if(signal==WAIT_OBJECT_0){				// メインスレッドからの介入により待機を解除した
			ReleaseMutex(hMutex);				// ミューテックスの所有権を解放
			SendMessage(hWnd,WM_MUTEX,0,0);		// メインスレッドにミューテックスの所有権取得を要求
		}
	}
}

/// マウス制御スレッド
/// カーソルによる左右下移動に対応させる(左右中ボタンは関与しない＝常に有効)
/// lpParameter：ウィンドウのハンドル
DWORD WINAPI MouseProc(LPVOID lpParameter)
{
	HWND hWnd=(HWND)lpParameter;
	POINT pt;

	while(!GameOver){
		Sleep(50);
		if(!MouseControl) continue;		/// マウスコントロール無効
		if(hWnd!=GetForegroundWindow()) continue;
		GetCursorPos(&pt);				/// ↑ウィンドウがアクティブになるまで待つ
		ScreenToClient(hWnd,&pt);		/// ↓ゲームフィールド内部
		if(pt.x>=CW && pt.x<(FW+1)*CW && pt.y>=CH && pt.y<FH*CH){
			if(pt.x < (Pos.x+2)*CW) PostMessage(hWnd,WM_KEYDOWN,VK_LEFT,0);
			else if(pt.x >= (Pos.x+3)*CW) PostMessage(hWnd,WM_KEYDOWN,VK_RIGHT,0);
			if(pt.y >= (Pos.y+2)*CH) PostMessage(hWnd,WM_KEYDOWN,VK_DOWN,0);
		}
	}
	return 0;
}

/// ルール設定ダイアログボックスのプロシージャ
LRESULT CALLBACK RuleDlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
	static DWORD oja,max,rnd,var,del,spd;
	static MCI_PLAY_PARMS mpp;

	switch(uMsg){
		case WM_INITDIALOG:
			mpp.dwCallback=(DWORD_PTR)hDlg;
			mciSendCommand(Mop[SETUP].wDeviceID,MCI_PLAY,MCI_NOTIFY,(DWORD_PTR)&mpp);

			oja=Ojama,max=OjaMax,rnd=OjaRand,var=Variety,del=Delete,spd=Speed;
			switch(oja){
				case 0: SendMessage(GetDlgItem(hDlg,IDC_OJAMA_0),BM_SETCHECK,BST_CHECKED,0); break;
				case 1: SendMessage(GetDlgItem(hDlg,IDC_OJAMA_1),BM_SETCHECK,BST_CHECKED,0); break;
				case 2: SendMessage(GetDlgItem(hDlg,IDC_OJAMA_2),BM_SETCHECK,BST_CHECKED,0); break;
				case 3: SendMessage(GetDlgItem(hDlg,IDC_OJAMA_3),BM_SETCHECK,BST_CHECKED,0); break;
			}
			switch(max){
				case  2: SendMessage(GetDlgItem(hDlg,IDC_MAXOJA_2 ),BM_SETCHECK,BST_CHECKED,0); break;
				case  4: SendMessage(GetDlgItem(hDlg,IDC_MAXOJA_4 ),BM_SETCHECK,BST_CHECKED,0); break;
				case  6: SendMessage(GetDlgItem(hDlg,IDC_MAXOJA_6 ),BM_SETCHECK,BST_CHECKED,0); break;
				case 12: SendMessage(GetDlgItem(hDlg,IDC_MAXOJA_12),BM_SETCHECK,BST_CHECKED,0); break;
			}
			switch(rnd){
				case 20: SendMessage(GetDlgItem(hDlg,IDC_OJARAND_20),BM_SETCHECK,BST_CHECKED,0); break;
				case 15: SendMessage(GetDlgItem(hDlg,IDC_OJARAND_15),BM_SETCHECK,BST_CHECKED,0); break;
				case 10: SendMessage(GetDlgItem(hDlg,IDC_OJARAND_10),BM_SETCHECK,BST_CHECKED,0); break;
				case  5: SendMessage(GetDlgItem(hDlg,IDC_OJARAND_5 ),BM_SETCHECK,BST_CHECKED,0); break;
			}
			switch(var){
				case 2: SendMessage(GetDlgItem(hDlg,IDC_VAR_2),BM_SETCHECK,BST_CHECKED,0); break;
				case 3: SendMessage(GetDlgItem(hDlg,IDC_VAR_3),BM_SETCHECK,BST_CHECKED,0); break;
				case 4: SendMessage(GetDlgItem(hDlg,IDC_VAR_4),BM_SETCHECK,BST_CHECKED,0); break;
				case 5: SendMessage(GetDlgItem(hDlg,IDC_VAR_5),BM_SETCHECK,BST_CHECKED,0); break;
				case 6: SendMessage(GetDlgItem(hDlg,IDC_VAR_6),BM_SETCHECK,BST_CHECKED,0); break;
			}
			switch(del){
				case 2: SendMessage(GetDlgItem(hDlg,IDC_DEL_2),BM_SETCHECK,BST_CHECKED,0); break;
				case 3: SendMessage(GetDlgItem(hDlg,IDC_DEL_3),BM_SETCHECK,BST_CHECKED,0); break;
				case 4: SendMessage(GetDlgItem(hDlg,IDC_DEL_4),BM_SETCHECK,BST_CHECKED,0); break;
				case 5: SendMessage(GetDlgItem(hDlg,IDC_DEL_5),BM_SETCHECK,BST_CHECKED,0); break;
				case 6: SendMessage(GetDlgItem(hDlg,IDC_DEL_6),BM_SETCHECK,BST_CHECKED,0); break;
			}
			switch(spd){
				case 1200: SendMessage(GetDlgItem(hDlg,IDC_SPEED_0),BM_SETCHECK,BST_CHECKED,0); break;
				case 1000: SendMessage(GetDlgItem(hDlg,IDC_SPEED_1),BM_SETCHECK,BST_CHECKED,0); break;
				case  800: SendMessage(GetDlgItem(hDlg,IDC_SPEED_2),BM_SETCHECK,BST_CHECKED,0); break;
				case  600: SendMessage(GetDlgItem(hDlg,IDC_SPEED_3),BM_SETCHECK,BST_CHECKED,0); break;
				case  400: SendMessage(GetDlgItem(hDlg,IDC_SPEED_4),BM_SETCHECK,BST_CHECKED,0); break;
			}
			return TRUE;
		case MM_MCINOTIFY:
			if(wParam==MCI_NOTIFY_SUCCESSFUL){
                mciSendCommand((MCIDEVICEID)lParam,MCI_SEEK,MCI_SEEK_TO_START,0);
                mciSendCommand((MCIDEVICEID)lParam,MCI_PLAY,MCI_NOTIFY,(DWORD_PTR)&mpp);
			}else{
                mciSendCommand((MCIDEVICEID)lParam,MCI_STOP,0,0);
                mciSendCommand((MCIDEVICEID)lParam,MCI_SEEK,MCI_SEEK_TO_START,0);
			}
			return TRUE;
		case WM_COMMAND:
			switch(LOWORD(wParam)){
				case IDOK:
					SendMessage(hDlg,MM_MCINOTIFY,MCI_NOTIFY_ABORTED,Mop[SETUP].wDeviceID);
					Ojama=oja; OjaMax=max; OjaRand=rnd; Variety=var; Delete=del; Speed=spd;
					EndDialog(hDlg,IDOK); return TRUE;
				case IDCANCEL:
	                SendMessage(hDlg,MM_MCINOTIFY,MCI_NOTIFY_ABORTED,Mop[SETUP].wDeviceID);
	                EndDialog(hDlg,IDCANCEL); return TRUE;
				case IDC_KEY: DialogBox(hInst,"KEY",hDlg,(DLGPROC)KeyDlgProc); return TRUE;
				case IDC_OJAMA_0: oja=0; return TRUE;		/// ↑キーコンフィグダイアログ
				case IDC_OJAMA_1: oja=1; return TRUE;
				case IDC_OJAMA_2: oja=2; return TRUE;
				case IDC_OJAMA_3: oja=3; return TRUE;
				case IDC_MAXOJA_2:  max= 2;  return TRUE;
				case IDC_MAXOJA_4:  max= 4;  return TRUE;
				case IDC_MAXOJA_6:  max= 6;  return TRUE;
				case IDC_MAXOJA_12: max=12; return TRUE;
				case IDC_OJARAND_20: rnd=20; return TRUE;
				case IDC_OJARAND_15: rnd=15; return TRUE;
				case IDC_OJARAND_10: rnd=10; return TRUE;
				case IDC_OJARAND_5:  rnd= 5;  return TRUE;
				case IDC_VAR_2: var=2; return TRUE;
				case IDC_VAR_3: var=3; return TRUE;
				case IDC_VAR_4: var=4; return TRUE;
				case IDC_VAR_5: var=5; return TRUE;
				case IDC_VAR_6: var=6; return TRUE;
				case IDC_DEL_2: del=2; return TRUE;
				case IDC_DEL_3: del=3; return TRUE;
				case IDC_DEL_4: del=4; return TRUE;
				case IDC_DEL_5: del=5; return TRUE;
				case IDC_DEL_6: del=6; return TRUE;
				case IDC_SPEED_0: spd=1200; return TRUE;
				case IDC_SPEED_1: spd=1000; return TRUE;
				case IDC_SPEED_2: spd= 800; return TRUE;
				case IDC_SPEED_3: spd= 600; return TRUE;
				case IDC_SPEED_4: spd= 400; return TRUE;
			}
			return FALSE;
	}
	return FALSE;
}

/// キーコンフィグダイアログボックスのプロシージャ
LRESULT CALLBACK KeyDlgProc(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
	static KEY button;
	static BOOL mouse;
	static WPARAM wp[KEYNUM];
	static char tempKeyText[KEYNUM][32];
	static char keyText[KEYNUM][32]={"A","F","Space","Left","Right","Down","Esc","Enter","F1"};
	const char ope[KEYNUM][32]={"左回転","右回転","反転","左移動","右移動","下移動",
		"ポーズ","ニューゲーム","キーコンフィグ"};
	const DWORD IDC[KEYNUM]={IDC_BTL,IDC_BTR,IDC_BTO,IDC_BML,IDC_BMR,IDC_BMD,IDC_BPA,IDC_BNG,IDC_BKC};
	char str[64];
	RECT rc;
	int i,k;

	switch(uMsg){
		case WM_INITDIALOG:
			for(i=0;i<KEYNUM;i++){
				wp[i]=Key[i]; strcpy(tempKeyText[i],keyText[i]);
				wsprintf(str,"%s ： %s",ope[i],tempKeyText[i]);
				SetWindowText(GetDlgItem(hDlg,IDC[i]),str);
			}
			mouse=MouseControl;
			if(mouse) SendMessage(GetDlgItem(hDlg,IDC_RMA),BM_SETCHECK,BST_CHECKED,0);
			else SendMessage(GetDlgItem(hDlg,IDC_RMN),BM_SETCHECK,BST_CHECKED,0);
			return TRUE;
		case WM_COMMAND:
			switch(LOWORD(wParam)){
				case IDOK:
					for(i=0;i<KEYNUM-1;i++){		/// 一つのキーが複数の操作に
						for(k=i+1;k<KEYNUM;k++){	/// 割り当てられていないか？
							if(wp[i]==wp[k]){
								MessageBox(hDlg,"同じキーが複数の操作に割り当てられています",NULL,MB_OK);
								return TRUE;
							}
						}
					}
					/// 異常なし
					for(i=0;i<KEYNUM;i++){Key[i]=wp[i]; strcpy(keyText[i],tempKeyText[i]);}
					MouseControl=mouse;
					EndDialog(hDlg,IDOK); return TRUE;
				case IDCANCEL: EndDialog(hDlg,IDCANCEL); return TRUE;
				case IDC_BTL: button=TL; break;
				case IDC_BTR: button=TR; break;
				case IDC_BTO: button=TO; break;
				case IDC_BML: button=ML; break;
				case IDC_BMR: button=MR; break;
				case IDC_BMD: button=MD; break;
				case IDC_BPA: button=PA; break;
				case IDC_BNG: button=NG; break;
				case IDC_BKC: button=KC; break;
				case IDC_RMA: mouse=TRUE; return TRUE;
				case IDC_RMN: mouse=FALSE; return TRUE;
				default: return FALSE;
			}
			wsprintf(str,"%s\n\n現在のキー：%s",ope[button],tempKeyText[button]);
			GetWindowRect(hDlg,&rc);
			CreateWindow("Input",NULL,WS_POPUP | WS_VISIBLE,
				rc.left,rc.top,rc.right-rc.left,rc.bottom-rc.top, 
				hDlg,NULL,hInst,str);
			return TRUE;
		case WM_INPUT:
			wp[button]=wParam;
			GetKeyNameText((LONG)lParam,tempKeyText[button],sizeof(tempKeyText[button]));
			wsprintf(str,"%s ： %s",ope[button],tempKeyText[button]);
			SetWindowText(GetDlgItem(hDlg,IDC[button]),str);
			return TRUE;
	}
	return FALSE;
}

/// 入力キー取得ウィンドウのプロシージャ
LRESULT CALLBACK InputWindowProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
	HDC hdc;
	PAINTSTRUCT ps;
	static RECT rc;
	static BOOL paint;
	char str[128];
	static char params[64];
	const char *explain="新たに割り当てたいキーを押して下さい";

	switch(uMsg){
		case WM_CREATE:
			strcpy(params,(char*)(((LPCREATESTRUCT)lParam)->lpCreateParams));
			GetClientRect(hWnd,&rc); rc.top=100;
			paint=TRUE; SetTimer(hWnd,1,500,NULL);
			return 0;
		case WM_TIMER:
			paint=!paint;
			InvalidateRect(hWnd,NULL,TRUE);
			return 0;
		case WM_PAINT:
			hdc=BeginPaint(hWnd,&ps);
			SetTextColor(hdc,RGB(0,255,0)); SetBkColor(hdc,RGB(0,0,0));
			if(paint) wsprintf(str,"%s\n\n%s",params,explain);
			else strcpy(str,params);
			DrawText(hdc,str,-1,&rc,DT_CENTER);
			EndPaint(hWnd,&ps);		/// ↓タスクバーの項目をクリックする事で
			return 0;				/// ↓再び最前面になった場合はフォーカスを失っている
		case WM_WINDOWPOSCHANGED: SetForegroundWindow(hWnd); return 0;
		case WM_KEYDOWN:
			PostMessage(GetWindow(hWnd,GW_OWNER),WM_INPUT,wParam,lParam);
			KillTimer(hWnd,1); DestroyWindow(hWnd);
			return 0;

	}
	return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

int WINAPI WinMain(
	HINSTANCE hInstance,HINSTANCE hPrevInstance,PSTR lpCmdLine,int nCmdShow)
{
	WNDCLASS wc;
	MSG msg;

	hInst=hInstance;

	wc.style		 = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc	 = WindowProc;
	wc.cbClsExtra	 = 0;
	wc.cbWndExtra	 = 0;
	wc.hInstance	 = hInstance;
	wc.hIcon		 = LoadIcon(NULL,IDI_APPLICATION);
	wc.hCursor		 = LoadCursor(NULL,IDC_ARROW);
	wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
	wc.lpszMenuName	 = NULL;
	wc.lpszClassName = __FILE__;
	if(!RegisterClass(&wc)) return 0;

	/// 入力キー取得ウィンドウ
	wc.lpfnWndProc	 = InputWindowProc;
	wc.lpszClassName = "Input";
	wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
	if(!RegisterClass(&wc)) return 0;

	// 指定したクライアント領域を確保するために必要なウィンドウ座標を計算する
	RECT rc={0,0,(FW+PW+3)*CW,(FH+1)*CH};
	AdjustWindowRect(&rc,WS_OVERLAPPEDWINDOW ^ WS_THICKFRAME,FALSE);

	HWND hWnd=CreateWindow(
		__FILE__,"とことんぷよぷよ",
		(WS_OVERLAPPEDWINDOW ^ WS_THICKFRAME ^ WS_MAXIMIZEBOX) | WS_VISIBLE,
		CW_USEDEFAULT,CW_USEDEFAULT,
		rc.right-rc.left,rc.bottom-rc.top, 
		NULL,NULL,hInstance,NULL);
	if(hWnd==NULL) return 0;

	BOOL bRet;
	while((bRet=GetMessage(&msg,NULL,0,0))!=0){
		if(bRet==-1) break;
		DispatchMessage(&msg);
	}

	return (int)msg.wParam;
}