MFC 프로젝트 - 테트리스 악마 모드

Study/MFC

MFC 프로젝트 - 테트리스 악마 모드

코딩하는 야구쟁이 2011. 9. 30. 20:05

// TemProject_20063703View.cpp : implementation of the CTemProject_20063703View class
//

#include "stdafx.h"
#include "TemProject_20063703.h"
#include <time.h>
#include <stdio.h>
#include <windows.h>

#include "TemProject_20063703Doc.h"
#include "TemProject_20063703View.h"
#include <mmsystem.h>               // 헤더파일 등록
#pragma comment(lib,"winmm.lib")    // 라이브러리 등록

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define random(n) (rand()%n)

/////////////////////////////////////////////////////////////////////////////
// CTemProject_20063703View

IMPLEMENT_DYNCREATE(CTemProject_20063703View, CView)

BEGIN_MESSAGE_MAP(CTemProject_20063703View, CView)
//{{AFX_MSG_MAP(CTemProject_20063703View)
ON_COMMAND(ID_GAMESTART, OnGamestart)
ON_WM_DESTROY()
ON_WM_KEYDOWN()
ON_WM_TIMER()
ON_WM_CHAR()
ON_COMMAND(ID_STOP, OnStop)
ON_COMMAND(ID_GAMESTART2, OnGamestart2)
ON_COMMAND(ID_ZIG, OnZig)
ON_COMMAND(ID_X, OnX)
ON_COMMAND(ID_RANDOM, OnRandom)
ON_COMMAND(ID_NOMAL, OnNomal)
ON_COMMAND(ID_TRY, OnTry)
//}}AFX_MSG_MAP
// Standard printing commands
ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CTemProject_20063703View construction/destruction
int pat[7][32]={
	{0,0,1,0,2,0,-1,0,0,0,0,1,0,-1,0,-2,},
	{0,0,1,0,0,1,1,1,},
	{0,0,-1,0,0,-1,1,-1,0,0,0,1,-1,0,-1,-1,},
	{0,0,-1,-1,0,-1,1,0,0,0,-1,0,-1,1,0,-1,},
	{0,0,0,-1,1,0,2,0,0,0,-1,0,0,-1,0,-2,0,0,-1,0,- 2,0,0,1,0,0,1,0,0,1,0,2},
	{0,0,-1,0,-2,0,0,-1,0,0,-1,0,0,1,0,2,0,0,0,1,1,0,2,0,0,0,1,0,0,-1,0,-2},
	{0,0,-1,0,1,0,0,1,0,0,0,-1,0,1,1,0,0,0,-1,0,1,0,0,-1,0,0,-1,0,0,-1,0,1}
};

int brickpatnum[7]={2,1,2,2,4,4,4};

CTemProject_20063703View::CTemProject_20063703View()
{
	
	// TODO: add construction code here
	//변수를 초기화 
	GameStart=false;
	GameStart2=false;
	timecheck=FALSE;
	map=1;
}

CTemProject_20063703View::~CTemProject_20063703View()
{
}

BOOL CTemProject_20063703View::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs
	
	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CTemProject_20063703View drawing

void CTemProject_20063703View::OnDraw(CDC* pDC)
{
	CTemProject_20063703Doc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// TODO: add draw code for native data here
	drawscreen(); 
}

/////////////////////////////////////////////////////////////////////////////
// CTemProject_20063703View printing

BOOL CTemProject_20063703View::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CTemProject_20063703View::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

void CTemProject_20063703View::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CTemProject_20063703View diagnostics

#ifdef _DEBUG
void CTemProject_20063703View::AssertValid() const
{
	CView::AssertValid();
}

void CTemProject_20063703View::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CTemProject_20063703Doc* CTemProject_20063703View::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTemProject_20063703Doc)));
	return (CTemProject_20063703Doc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CTemProject_20063703View message handlers
//1Player 시작시
void CTemProject_20063703View::OnGamestart() 
{
	// TODO: Add your command handler code here

m_SoundMgr.StopMid();
	m_SoundMgr.Music();
	//2p에서 1p로 전환할 경우 2p의 블럭을 지우고 타이머를 해제한다.
	KillTimer(2);
	printscore();
	//배열 초기화
	for(i=0;i<23;i++) for(j=0;j<14;j++) tet[j][i]=0;
	//아이템 리스트 초기화
	for(i=0;i<20;i++)item[i]=0;
	//유저가 선택한 맵으로 설정
	switch(map){
	case 1:
		for (i=0;i<23;i++)for(j=0;j<14;j++) {    // 배열을 초기화한다.
			if (i>=21 || j==0 || j==13) tet[j][i]=3;
			else tet[j][i]=0;
		}
			break;
	case 2:
		//랜덤
		for (i=0;i<23;i++)for(j=0;j<14;j++)     // 배열을 초기화한다.
			if (i==21 || j==0 || j==13) tet[j][i]=3;
			else if (i>15&&j>7) tet[random(20)*GetTickCount()%12+1][random(20)*GetTickCount()%7+13]=2;
			else tet[j][i]=0;
			break;
	case 3:
		//이등변 삼각형
		for(i=0;i<23;i++) {
			for(j=0;j<14;j++){
				if(i>=21 || j==0 || j>=13) tet[j][i]=3;
				else if(j<i-8) tet[j][i]=2;
				else tet[j][i]=0;
			}
		}
		break;
	case 5:
		//지그재그
		for(i=0;i<23;i++){
			for(j=0;j<14;j++){
				if(i>=21 || j==0 || j>=13)tet[j][i]=3;
				else if(i%2==0&&i>8){
					if(i%4==0&&j>4) tet[j][i]=2;
					else if(i%4!=0&&j<8) tet[j][i]=2;
					else tet[j][i]=0;
				}
				else tet[j][i]=0;
			}
		}
		break;
	case 4:
		//x
		for(i=0;i<23;i++){
			for(j=0;j<14;j++){
				if(i>=21 || j==0 || j>=13) tet[j][i]=3;
				else if(j<i-4){
					if(j==i-9&&j!=1){
						tet[j][i]=2;
						tet[13-j][i]=2;
						tet[11][11]=2;
						tet[10][12]=2;
						tet[9][13]=2;
					}
				}
				else tet[j][i]=0;
			}
		}
		break;
	}	
	//변수들 초기화
	speed=500;
	score=0;
	SetTimer(1,speed,NULL);
	nextbrick=random(7)*GetTickCount()%7;
	nowbrick=GetTickCount()%7;
	savebrick=-1;//현재 홀드되어있는 변수
	savecheck=0;//교환회수를 저장하기 위한 변수
	tempbrick=0;//교환을 위한 임시 변수
	makenewblock(1);
	timecheck=false;//현재 게임이 진행중인지 정지중인지 판별하는 함수
	nowytemp=-1;//gost 위치를 알아내기위한 변수
	GameStart=TRUE;
	GameStart2=false;
	nowitem=0;//현재 아이템 위치를 가르키는 변수
	attack=0;//제거한 라인수를 나타내는 변수
	drawscreen();
	InvalidateRect(NULL,TRUE);
	//	UpdateWindow();
}
//블록을 그려주는 함수
void CTemProject_20063703View::brick(int flag)
{
	CClientDC dc(this);
	CDC MemDC;
	MemDC.CreateCompatibleDC(&dc);
	CBitmap blank,blick,blick2;
	blank.LoadBitmap(IDB_BLANK1); 
	//현재 블록에 따라 다른 이미지를 로드한다.
	switch (nowbrick){
	case 0:blick.LoadBitmap(IDB_BRICK1);break;
	case 1:blick.LoadBitmap(IDB_BRICK2);break;
	case 2:blick.LoadBitmap(IDB_BRICK3);break;
	case 3:blick.LoadBitmap(IDB_BRICK4);break;
	case 4:blick.LoadBitmap(IDB_BRICK5);break;
	case 5:blick.LoadBitmap(IDB_BRICK6);break;
	case 6:blick.LoadBitmap(IDB_BRICK7);break;
	}
	if(GameStart2==true){
		switch (nowbrick2){
		case 0:blick2.LoadBitmap(IDB_BRICK1);break;
		case 1:blick2.LoadBitmap(IDB_BRICK2);break;
		case 2:blick2.LoadBitmap(IDB_BRICK3);break;
		case 3:blick2.LoadBitmap(IDB_BRICK4);break;
		case 4:blick2.LoadBitmap(IDB_BRICK5);break;
		case 5:blick2.LoadBitmap(IDB_BRICK6);break;
		case 6:blick2.LoadBitmap(IDB_BRICK7);break;
		}
	}
	
	CBitmap *pOldBitmap = (CBitmap *)MemDC.SelectObject(&blick);
	// 0이면 1Player 블록을 지운다.
	if (flag==0){
		for (i=0;i<4;i++){    
			MemDC.SelectObject(&blank);	
			dc.BitBlt((nowx+pat[nowbrick][nowrot*8+i*2]-1)*35+10,
				(nowy+pat[nowbrick][nowrot*8+i*2+1]-1)*35+10,35,35,&MemDC,0,0,SRCCOPY);
			MemDC.SelectObject(pOldBitmap);
		}
	}
	// 1이면 1Player 블록을 그린다.
	else if(flag==1){
		for (i=0;i<4;i++){     
			MemDC.SelectObject(&blick);	
			dc.BitBlt((nowx+pat[nowbrick][nowrot*8+i*2]-1)*35+10,
				(nowy+pat[nowbrick][nowrot*8+i*2+1]-1)*35+10,35,35,&MemDC,0,0,SRCCOPY);
			MemDC.SelectObject(pOldBitmap);
		}
	}
	// 2이면 2Player 블록을 지운다.
	else if(flag==2){
		for (i=0;i<4;i++){   
			MemDC.SelectObject(&blank);	
			dc.BitBlt((nowx2+pat[nowbrick2][nowrot2*8+i*2]-1)*35+10+800,
				(nowy2+pat[nowbrick2][nowrot2*8+i*2+1]-1)*35+10,35,35,&MemDC,0,0,SRCCOPY);
			MemDC.SelectObject(pOldBitmap);
		}
	}
	// 3이면 2Player 블록을 그린다.
	else if(flag==3){
		for (i=0;i<4;i++){     
			MemDC.SelectObject(&blick2);	
			dc.BitBlt((nowx2+pat[nowbrick2][nowrot2*8+i*2]-1)*35+10+800,
				(nowy2+pat[nowbrick2][nowrot2*8+i*2+1]-1)*35+10,35,35,&MemDC,0,0,SRCCOPY);
			MemDC.SelectObject(pOldBitmap);
		}
	}	
}
//다음 블록을 그리는 함수
void CTemProject_20063703View::drawnextbrick()
{
	CClientDC dc(this);
	CDC MemDC;
	MemDC.CreateCompatibleDC(&dc);
	CBrush brush;
	brush.CreateSolidBrush(RGB(255,255,255));
	CBitmap blick,blick2;
	CBitmap *pOldBitmap = (CBitmap *)MemDC.SelectObject(&blick);
	//1P Next bluck 사각형
	Rectangle(dc,10,720,215,900);
	//다음 벽돌 위치
	RECT rect={11,721,214,899};
	//흰색으로 덧칠해 준다.(겹치지 않도록)
	dc.FillRect(&rect,&brush);
	//text출력
	dc.TextOut(75,730,"Next Bluck", 10);

if(GameStart2==true){
		Rectangle(dc,810,720,1015,900); 
		RECT rect2={811,721,1014,899};
		dc.FillRect(&rect2,&brush);
		dc.TextOut(875,730,"Next Bluck", 10);
	}
	MemDC.SelectObject(&blick);
	//다음 블록도 블록별로 이미지를 각각 로드해준다.
	switch (nextbrick){
	case 0: blick.LoadBitmap(IDB_BRICK1); break;
	case 1:	blick.LoadBitmap(IDB_BRICK2); break;
	case 2: blick.LoadBitmap(IDB_BRICK3); break;
	case 3: blick.LoadBitmap(IDB_BRICK4); break;
	case 4: blick.LoadBitmap(IDB_BRICK5); break;
	case 5: blick.LoadBitmap(IDB_BRICK6); break;
	case 6: blick.LoadBitmap(IDB_BRICK7); break;
	}
	if(GameStart2==true){
		switch (nextbrick2){
		case 0: blick2.LoadBitmap(IDB_BRICK1); break;
		case 1: blick2.LoadBitmap(IDB_BRICK2); break;
		case 2: blick2.LoadBitmap(IDB_BRICK3); break;
		case 3: blick2.LoadBitmap(IDB_BRICK4); break;
		case 4:	blick2.LoadBitmap(IDB_BRICK5); break;
		case 5: blick2.LoadBitmap(IDB_BRICK6); break;
		case 6: blick2.LoadBitmap(IDB_BRICK7); break;
		}
	}
	MemDC.SelectObject(&blick);
	for(i=0;i<4;i++) dc.BitBlt((17+pat[nextbrick][i*2]-1)*35-470,(18+pat[nextbrick][i*2+1]-1)*35+210,35,35,&MemDC,0,0,SRCCOPY);
	if(GameStart2==true){
		MemDC.SelectObject(&blick2);
		for(i=0;i<4;i++) dc.BitBlt((17+pat[nextbrick2][i*2]-1)*35+330,(18+pat[nextbrick2][i*2+1]-1)*35+210,35,35,&MemDC,0,0,SRCCOPY);
	}
	MemDC.SelectObject(pOldBitmap);	
}
//본화면을 다시 그리는 함수
void CTemProject_20063703View::drawscreen()
{
	CClientDC dc(this);
	CDC MemDC;
	MemDC.CreateCompatibleDC(&dc);
	CBitmap blank,blick1,stack,blick10,blick11,blick12,blick13,blick14,blick15,premap,item1,item22,item3,item4,item5,item6,item7,item8,item9;
	blank.LoadBitmap(IDB_BLANK1);
	stack.LoadBitmap(IDB_STACK);
	blick1.LoadBitmap(IDB_BRICK1);
	blick10.LoadBitmap(IDB_BRICK2);
	blick11.LoadBitmap(IDB_BRICK3);
	blick12.LoadBitmap(IDB_BRICK4);
	blick13.LoadBitmap(IDB_BRICK5);
	blick14.LoadBitmap(IDB_BRICK6);
	blick15.LoadBitmap(IDB_BRICK7);
	item1.LoadBitmap(IDB_LINEUP);
	item22.LoadBitmap(IDB_LINEDOWN);
	item3.LoadBitmap(IDB_CHANGE);
	item4.LoadBitmap(IDB_SPEEDUP);
	item5.LoadBitmap(IDB_SPEEDDOWN);
	item6.LoadBitmap(IDB_ITEMBLANK);
	item7.LoadBitmap(IDB_BLOCK);
	item8.LoadBitmap(IDB_ITEMDELETE);
	item9.LoadBitmap(IDB_CLEAR);
	CBitmap *pOldBitmap = (CBitmap *)MemDC.SelectObject(&blick1);
	//게임이 실행되면 점수판을 출력한다.
	if(GameStart==true) printscore();
	//현재 선택된 맵에 따라 이미지를 로드한다.
	switch(map){
	case 1: premap.LoadBitmap(IDB_MAP1); break;
	case 2: premap.LoadBitmap(IDB_MAP2); break;
	case 3: premap.LoadBitmap(IDB_MAP3); break;
	case 4: premap.LoadBitmap(IDB_MAP4); break;
	case 5: premap.LoadBitmap(IDB_MAP5); break;
	}
	MemDC.SelectObject(&premap);
	dc.BitBlt(490,270,260,300,&MemDC,0,0,SRCCOPY);
	MemDC.SelectObject(pOldBitmap);
	// 배열값을 일일이 읽어서 벽돌들을 출력해 준다.
	for (i=1;i<=20;i++){ 
		for (j=1;j<=12;j++){
			switch(tet[j][i]){
			case 0:MemDC.SelectObject(&blank);break;
			case 2:MemDC.SelectObject(&stack);break;
			case 10:MemDC.SelectObject(&blick1);break;
			case 11:MemDC.SelectObject(&blick10);break;
			case 12:MemDC.SelectObject(&blick11);break;
			case 13:MemDC.SelectObject(&blick12);break;
			case 14:MemDC.SelectObject(&blick13);break;
			case 15:MemDC.SelectObject(&blick14);break;
			case 16:MemDC.SelectObject(&blick15);break;
			case 21:MemDC.SelectObject(&item1);break;
			case 22:MemDC.SelectObject(&item22);break;
			case 23:MemDC.SelectObject(&item8);break;
			case 24:MemDC.SelectObject(&item9);break;
			case 26:MemDC.SelectObject(&item3);break;
			case 27:MemDC.SelectObject(&item4);break;
			case 28:MemDC.SelectObject(&item5);break;
			default:break;
			}
			dc.BitBlt((j-1)*35+10,(i-1)*35+10,35,35,&MemDC,0,0,SRCCOPY);
			MemDC.SelectObject(pOldBitmap);
			if(GameStart2==true){
				switch(tet2[j][i]){
				case 0:MemDC.SelectObject(&blank);break;
				case 2:MemDC.SelectObject(&stack);break;
				case 10:MemDC.SelectObject(&blick1);break;
				case 11:MemDC.SelectObject(&blick10);break;
				case 12:MemDC.SelectObject(&blick11);break;
				case 13:MemDC.SelectObject(&blick12);break;
				case 14:MemDC.SelectObject(&blick13);break;
				case 15:MemDC.SelectObject(&blick14);break;
				case 16:MemDC.SelectObject(&blick15);break;
				case 21:MemDC.SelectObject(&item1);break;
				case 22:MemDC.SelectObject(&item22);break;
				case 23:MemDC.SelectObject(&item8);break;
				case 24:MemDC.SelectObject(&item9);break;
				case 26:MemDC.SelectObject(&item3);break;
				case 27:MemDC.SelectObject(&item4);break;
				case 28:MemDC.SelectObject(&item5);break;
				default:break;
				}
				dc.BitBlt((j-1)*35+10+800,(i-1)*35+10,35,35,&MemDC,0,0,SRCCOPY);
				MemDC.SelectObject(pOldBitmap);
			}
		}
	}
	//아이템 리스트를 출력해 준다.
	for(i=0;i<20;i++){
		switch(item[i]){
		case 0:MemDC.SelectObject(&item6);break;
		case 21:MemDC.SelectObject(&item1);break;
		case 22:MemDC.SelectObject(&item22);break;
		case 23:MemDC.SelectObject(&item8);break;
		case 24:MemDC.SelectObject(&item9);break;
		case 26:MemDC.SelectObject(&item3);break;
		case 27:MemDC.SelectObject(&item4);break;
		case 28:MemDC.SelectObject(&item5);break;
		default:break;
		}
		dc.BitBlt((j-1)*35+13,(i-1)*35+45,35,35,&MemDC,0,0,SRCCOPY);
		MemDC.SelectObject(pOldBitmap);
		if(GameStart2==true){
			switch(item2[i]){
			case 0:MemDC.SelectObject(&item6);break;
			case 21:MemDC.SelectObject(&item1);break;
			case 22:MemDC.SelectObject(&item22);break;
			case 23:MemDC.SelectObject(&item8);break;
			case 24:MemDC.SelectObject(&item9);break;
			case 26:MemDC.SelectObject(&item3);break;
			case 27:MemDC.SelectObject(&item4);break;
			case 28:MemDC.SelectObject(&item5);break;
			default:break;
			}
			dc.BitBlt((j-1)*35+353,(i-1)*35+45,35,35,&MemDC,0,0,SRCCOPY);
			MemDC.SelectObject(pOldBitmap);
		}
	}
	//게임 진행중이 아닐시 리턴한다.
	if(!GameStart) return;
	drawnextbrick();
	drawsavebrick();
}
//배열에 기록하고 라인을 지우는 기능을 하는 함수
void CTemProject_20063703View::isfull(int flag)
{
	int check,check2;
	int k,a;
	if(flag==1){
		attack=0;
		score++;
		printscore();
		//현재 블록에 따라 각각 다른값을 넣어준다.
		switch(nowbrick){
		case 0:
			for (i=0;i<4;i++)
				tet[nowx+pat[nowbrick][nowrot*8+i*2]]
				[nowy+pat[nowbrick][nowrot*8+i*2+1]]=10;
			break;
		case 1:
			for (i=0;i<4;i++)      
				tet[nowx+pat[nowbrick][nowrot*8+i*2]]
				[nowy+pat[nowbrick][nowrot*8+i*2+1]]=11;
			break;
		case 2:
			for (i=0;i<4;i++)      
				tet[nowx+pat[nowbrick][nowrot*8+i*2]]
				[nowy+pat[nowbrick][nowrot*8+i*2+1]]=12;
			break;
		case 3:
			for (i=0;i<4;i++)      
				tet[nowx+pat[nowbrick][nowrot*8+i*2]]
				[nowy+pat[nowbrick][nowrot*8+i*2+1]]=13;
			break;
		case 4:
			for (i=0;i<4;i++)       
				tet[nowx+pat[nowbrick][nowrot*8+i*2]]
				[nowy+pat[nowbrick][nowrot*8+i*2+1]]=14;
			break;
		case 5:
			for (i=0;i<4;i++)       
				tet[nowx+pat[nowbrick][nowrot*8+i*2]]
				[nowy+pat[nowbrick][nowrot*8+i*2+1]]=15;
			break;
		case 6:
			for (i=0;i<4;i++)       
				tet[nowx+pat[nowbrick][nowrot*8+i*2]]
				[nowy+pat[nowbrick][nowrot*8+i*2+1]]=16;
			break;
		}
		check2=0;
		//라인이 지워져야하는지 검사한다.
		for (i=20;i>=0;i--) {     
			check=0;
			for (j=1;j<13;j++)
				if (tet[j][i]==0) check=1;
				//공백이 없으면(지워져야하는 라인이 발견되면)
				if (check==0) {
					//지워지는 사운드 출력
						PlaySound(MAKEINTRESOURCE(IDR_LINEDELETE),0, SND_RESOURCE | SND_ASYNC);
						//아이템 위치를 가르키는 변수가 20을 넘지 않으면
					if(nowitem<20){
						//없어지는 라인에 아이템이 있는가 검사한다.
						//있으면 아이템리스트에 그에 해당하는 값을 넣어주고 현재 위치를 올려준다.
						for(a=1;a<13;a++){
							if(tet[a][i]==26){
								item[nowitem]=26;
								nowitem++;
							}
							if(tet[a][i]==27){
								item[nowitem]=27;
								nowitem++;
							}
							if(tet[a][i]==28){
								item[nowitem]=28;
								nowitem++;
							}
							if(tet[a][i]==21){
								item[nowitem]=21;
								nowitem++;
							}
							if(tet[a][i]==22){
								item[nowitem]=22;
								nowitem++;
							}
							if(tet[a][i]==23){
								item[nowitem]=23;
								nowitem++;
							}
							if(tet[a][i]==24){
								item[nowitem]=24;
								nowitem++;
							}
						}
					}
					score+=30;
					printscore();
					check2=1;
					attack++;
					for (k=i-1;k>0;k--)      
						for (j=1;j<13;j++)       
							tet[j][k+1]=tet[j][k];
						i++;
				}
		}
		//3줄이상 한번에 제거시 상대방의 블록을 증가시키는 함수이다.
		plus(1,attack);
		if(map!=1){
			if(!endcheck(1)) {
				KillTimer(1);
				KillTimer(2);
				GameStart=FALSE;
				if(MessageBox("Mission Sucess","Continue?",MB_YESNO | MB_ICONHAND)==IDYES){
					SendMessage(WM_COMMAND,ID_GAMESTART,NULL);
					return;
				}
				else {
					EnableMenuItem(0,ID_GAMESTART,MF_BYCOMMAND | MF_ENABLED);
					return;
				}
			}
		}
		if (check2==0) return; 
		//2Player 가 게임을 하고 있으면 아이템을 추가한다.
		if(GameStart2==true) if(check2!=0) itemplus(1,attack);
		score+=150;
		KillTimer(1);
		speed-=10;
		if (speed<100) speed=100;
		SetTimer(1,speed,NULL);
	}
	else{
		score2++;
		attack2=0;
		printscore();
		for (i=0;i<4;i++)       
			switch(nowbrick2){
			case 0:
				tet2[nowx2+pat[nowbrick2][nowrot2*8+i*2]]
					[nowy2+pat[nowbrick2][nowrot2*8+i*2+1]]=10;
				break;
			case 1:
				tet2[nowx2+pat[nowbrick2][nowrot2*8+i*2]]
					[nowy2+pat[nowbrick2][nowrot2*8+i*2+1]]=11;
				break;
			case 2:
				tet2[nowx2+pat[nowbrick2][nowrot2*8+i*2]]
					[nowy2+pat[nowbrick2][nowrot2*8+i*2+1]]=12;
				break;
			case 3:
				tet2[nowx2+pat[nowbrick2][nowrot2*8+i*2]]
					[nowy2+pat[nowbrick2][nowrot2*8+i*2+1]]=13;
				break;
			case 4:
				tet2[nowx2+pat[nowbrick2][nowrot2*8+i*2]]
					[nowy2+pat[nowbrick2][nowrot2*8+i*2+1]]=14;
				break;
			case 5:
				tet2[nowx2+pat[nowbrick2][nowrot2*8+i*2]]
					[nowy2+pat[nowbrick2][nowrot2*8+i*2+1]]=15;
				break;
			case 6:
				tet2[nowx2+pat[nowbrick2][nowrot2*8+i*2]]
					[nowy2+pat[nowbrick2][nowrot2*8+i*2+1]]=16;
				break;
		}
		check2=0;
		for (i=20;i>=0;i--) {   
			check=0;
			for (j=1;j<13;j++)
				if (tet2[j][i]==0) check=1;
				if (check==0) { 
						PlaySound(MAKEINTRESOURCE(IDR_LINEDELETE),0, SND_RESOURCE | SND_ASYNC);
					if(nowitem2<20){
						for(a=1;a<13;a++){
							if(tet2[a][i]==26){
								item2[nowitem2]=26;
								nowitem2++;
							}
							if(tet2[a][i]==27){
								item2[nowitem2]=27;
								nowitem2++;
							}
							if(tet2[a][i]==28){
								item2[nowitem2]=28;
								nowitem2++;
							}
							if(tet2[a][i]==21){
								item2[nowitem2]=21;
								nowitem2++;
							}
							if(tet2[a][i]==22){
								item2[nowitem2]=22;
								nowitem2++;
							}
							if(tet2[a][i]==23){
								item2[nowitem2]=23;
								nowitem2++;
							}
							if(tet2[a][i]==24){
								item2[nowitem2]=24;
								nowitem2++;
							}
						}
					}
					score2+=30;
					printscore();
					check2=1;
					attack2++;
					for (k=i-1;k>0;k--)      
						for (j=1;j<13;j++)       
							tet2[j][k+1]=tet2[j][k];
						i++;
				}
		}
		plus(2,attack2);
		if(map!=1){
			if(!endcheck(2)) {
				KillTimer(1);
				KillTimer(2);
				GameStart=FALSE;
				if(MessageBox("Mission Sucess","Continue?",MB_YESNO | MB_ICONHAND)==IDYES){
					SendMessage(WM_COMMAND,ID_GAMESTART,NULL);
					return;
				}
				else {
					EnableMenuItem(0,ID_GAMESTART,MF_BYCOMMAND | MF_ENABLED);
					return;
				}
			}
		}
		if (check2==0) return; 
		if(check2!=0) itemplus(2,attack2);
		score2+=150;
		KillTimer(2);
		speed2-=10;
		if (speed2<100) speed2=100;
		SetTimer(2,speed2,NULL);
	}
	nowytemp=-1;
	nowytemp2=-1;
	drawscreen();
}

//블록을 왼쪽으로 이동하는 함수
void CTemProject_20063703View::leftmove(int flag)
{
	if(flag==1){
		if (whataround(1,nowx-1,nowy)!=0) 
			return;
		brick(0);
		drawshadow(0);
		nowx-=1; 
		brick(1);
		drawshadow(1);
		brick(1);
	}
	else{
		if (whataround(2,nowx2-1,nowy2)!=0) 
			return;
		brick(2);
		drawshadow(2);
		nowx2-=1; 
		brick(3);
		drawshadow(3);
		brick(3);
	}
}

void CTemProject_20063703View::OnDestroy() 
{
	CView::OnDestroy();
	
	// TODO: Add your message handler code here
	KillTimer(1);	
}

void CTemProject_20063703View::OnInitialUpdate() 
{
	CView::OnInitialUpdate();
	
	// TODO: Add your specialized code here and/or call the base class
}

void CTemProject_20063703View::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	// TODO: Add your message handler code here and/or call default
	//게임 시작중이 아니면 리턴
	if (GameStart==FALSE) 
		return;
	switch(nChar) 
	{
	case VK_TAB:
		shiftdown(1);
		break;
	case VK_SHIFT:
		if(GameStart2==true) shiftdown(2);
		break;
	case VK_LEFT: 
		if(GameStart2==true){
			leftmove(2);
		}
		break;
	case VK_RIGHT: 
		if(GameStart2==true){
			rightmove(2);
		}
		break;
	case VK_UP: 
		if(GameStart2==true){
			rotate(2);
			PlaySound(MAKEINTRESOURCE(IDR_BLOCKTURN),0, SND_RESOURCE | SND_ASYNC);
		}
		break;
	case VK_DOWN:
		if(GameStart2==true){
			downmove(2);
		}
		break;
		//BACKSPACE를 누르면 stop 상태
	case VK_BACK:
		OnStop();
		break;	
	}
	
	CView::OnKeyDown(nChar, nRepCnt, nFlags);
}

void CTemProject_20063703View::OnTimer(UINT nIDEvent) 
{
	// TODO: Add your message handler code here and/or call default
	if(GameStart2==false) KillTimer(2);
	if(nIDEvent==1){
		if (downmove(1)==0) makenewblock(1);
	}
	else {
		if (downmove(2)==0) makenewblock(2);
	}
	CView::OnTimer(nIDEvent);
}

void CTemProject_20063703View::printscore()
{
	CClientDC dc(this);
	CDC MemDC;
	MemDC.CreateCompatibleDC(&dc);
	CBitmap gaze,gaze2;
	if(GameStart==true){
		wsprintf(imsistr,"score : %d",score);
		//1p점수판 위치
		TextOut(dc,550,100,imsistr,strlen(imsistr)); 
		wsprintf(imsistr2,"save count : %d",savecheck);
		TextOut(dc,550,150,imsistr2,strlen(imsistr2));
	}
	if(GameStart2==true){
		wsprintf(imsistr,"score : %d",score2);
		//2p점수판 위치
		TextOut(dc,550,700,imsistr,strlen(imsistr));
		wsprintf(imsistr2,"save count : %d",savecheck2);
		TextOut(dc,550,750,imsistr2,strlen(imsistr2));
	}
	//speed 에 맞는 게이지 이미지를 로드한다.
	switch(speed/100){
	case 1:gaze.LoadBitmap(IDB_BITMAP7);break;
	case 2:gaze.LoadBitmap(IDB_BITMAP6);break;
	case 3:gaze.LoadBitmap(IDB_BITMAP5);break;
	case 4:gaze.LoadBitmap(IDB_BITMAP4);break;
	case 5:gaze.LoadBitmap(IDB_BITMAP3);break;
	}
	switch(speed2/100){
	case 1:gaze2.LoadBitmap(IDB_BITMAP7);break;
	case 2:gaze2.LoadBitmap(IDB_BITMAP6);break;
	case 3:gaze2.LoadBitmap(IDB_BITMAP5);break;
	case 4:gaze2.LoadBitmap(IDB_BITMAP4);break;
	case 5:gaze2.LoadBitmap(IDB_BITMAP3);break;
	}
	CBitmap *pOldBitmap = (CBitmap *)MemDC.SelectObject(&gaze);	
	if(GameStart==true){
		wsprintf(imsistr3,"speed ");
		TextOut(dc,550,200,imsistr3,strlen(imsistr3));
		MemDC.SelectObject(&gaze);	
		dc.BitBlt(600,185,150,50,&MemDC,0,0,SRCCOPY);	
	}
	if(GameStart2==true){
		wsprintf(imsistr3,"speed");
		TextOut(dc,550,800,imsistr3,strlen(imsistr3));
		MemDC.SelectObject(&gaze2);	
		dc.BitBlt(600,785,150,50,&MemDC,0,0,SRCCOPY);
	}
	MemDC.SelectObject(pOldBitmap);
}
//블록을 오른쪽으로 이동하는 함수
void CTemProject_20063703View::rightmove(int flag)
{
	if(flag==1){
		if (whataround(1,nowx+1,nowy)!=0) 
			return;
		brick(0);
		drawshadow(0);
		nowx+=1; 
		brick(1);
		drawshadow(1);
		brick(1);
	}
	else{
		if (whataround(2,nowx2+1,nowy2)!=0) 
			return;	
		brick(2);
		drawshadow(2);
		nowx2+=1; 
		brick(3);
		drawshadow(3);
		brick(3);
	}
}
//회전하는 함수
void CTemProject_20063703View::rotate(int flag)
{
	int imsi,imsi2;
	if(flag==1){
		imsi=nowrot;
		nowrot++;
		if (nowrot==brickpatnum[nowbrick]) nowrot=0;
		if (whataround(1,nowx,nowy)!=0){
			nowrot=imsi;
			return;
		}
		imsi2=nowrot;
		nowrot=imsi;
		brick(0);
		drawshadow(0);
		nowrot=imsi2;
		brick(1);
		drawshadow(1);
		brick(1);
	}
	else{
		imsi=nowrot2;
		nowrot2++;
		if (nowrot2==brickpatnum[nowbrick2]) nowrot2=0;
		if (whataround(2,nowx2,nowy2)!=0) {
			nowrot2=imsi;
			return;
		}
		imsi2=nowrot2;
		nowrot2=imsi;
		brick(2);
		drawshadow(2);
		nowrot2=imsi2;
		brick(3);
		drawshadow(3);
		brick(3);
	}
}
//현재 블록과 회전상태를 고려해 주변을 검색하는 함수
int CTemProject_20063703View::whataround(int flag,int x, int y)
{
	k=0;
	if(flag==1){
		for (i=0;i<4;i++) {
			j=tet[x+pat[nowbrick][nowrot*8+i*2]]
				[y+pat[nowbrick][nowrot*8+i*2+1]];
			if (j>k) k=j;
		}
		return k;
	}
	else{
		for (i=0;i<4;i++) {
			j=tet2[x+pat[nowbrick2][nowrot2*8+i*2]]
				[y+pat[nowbrick2][nowrot2*8+i*2+1]];
			if (j>k) k=j;
		}
		return k;
	}
}
//미션맵을 선택했을때 미션을 끝냈는지 확인하는 함수
int CTemProject_20063703View::endcheck(int flag)
{
	for(i=0;i<21;i++){
		for(j=1;j<13;j++){
			if(flag==1){
				if(tet[j][i]==2) return 1;
			}
			else{
				if(tet2[j][i]==2) return 1;
			}
		}
	}
	return 0;
}
//홀드키를 그리는 함수
void CTemProject_20063703View::drawsavebrick()
{
	CClientDC dc(this);
	CDC MemDC;
	MemDC.CreateCompatibleDC(&dc);
	CBrush brush;
	brush.CreateSolidBrush(RGB(255,255,255));
	CBitmap blick,blick2;
	CBitmap *pOldBitmap = (CBitmap *)MemDC.SelectObject(&blick);
	// 1p Save bluck 사각형
	Rectangle(dc,225,720,430,900);
	RECT rect={226,721,429,899};
	dc.FillRect(&rect,&brush);
	dc.TextOut(270,730,"Block Save State",16);
	if(GameStart2==true) {
		// 2p Save bluck 사각형
		Rectangle(dc,1025,720,1230,900); 
		RECT rect2={1026,721,1229,899};  
		dc.FillRect(&rect2,&brush);
		dc.TextOut(1070,730,"Block Save State",16);
	}
	//현재 홀드된 키에따라 각각의 이미지를 로드해 준다.
	switch (savebrick){
	case 0:blick.LoadBitmap(IDB_BRICK1);break;
	case 1:blick.LoadBitmap(IDB_BRICK2);break;
	case 2:blick.LoadBitmap(IDB_BRICK3);break;
	case 3:blick.LoadBitmap(IDB_BRICK4);break;
	case 4:blick.LoadBitmap(IDB_BRICK5);break;
	case 5:blick.LoadBitmap(IDB_BRICK6);break;
	case 6:blick.LoadBitmap(IDB_BRICK7);break;
	}
	if(GameStart2==true){
		switch (savebrick2){
		case 0:blick2.LoadBitmap(IDB_BRICK1);break;
		case 1:blick2.LoadBitmap(IDB_BRICK2);break;
		case 2:blick2.LoadBitmap(IDB_BRICK3);break;
		case 3:blick2.LoadBitmap(IDB_BRICK4);break;
		case 4:blick2.LoadBitmap(IDB_BRICK5);break;
		case 5:blick2.LoadBitmap(IDB_BRICK6);break;
		case 6:blick2.LoadBitmap(IDB_BRICK7);break;
		}
	}
	MemDC.SelectObject(&blick);
	for (i=0;i<4;i++) {
		dc.BitBlt((17+pat[savebrick][i*2]-1)*35-250,(18+pat[savebrick][i*2+1]-1)*35+210,35,35,&MemDC,0,0,SRCCOPY);
		MemDC.SelectObject(pOldBitmap);	
	}
	if(GameStart2==true){
		MemDC.SelectObject(&blick2);
		for (i=0;i<4;i++){ 
			dc.BitBlt((17+pat[savebrick2][i*2]-1)*35+550,(18+pat[savebrick2][i*2+1]-1)*35+210,35,35,&MemDC,0,0,SRCCOPY);
			MemDC.SelectObject(pOldBitmap);	
		}
	}
}
//유저가 홀드키를 눌렀을 때 실행되는 함수
void CTemProject_20063703View::shiftdown(int flag)
{
	if(flag==1){
		//회수를 제한하는 변수 1증가
		savecheck++;
		if(savecheck>10) return;
		if (whataround(1,nowx,nowy)!=0)return;
		else
		{
			//그림자로 인해 지워지는 블록을 방지하기위해 nowytemp를 -1로 초기화한다.
			nowytemp=-1;
			//현재 홀드 되어있는 블록이 없다면
			if(savebrick==-1){
				savebrick=nowbrick;
				makenewblock(1);
			}
			else{
				//교환한다.
				tempbrick=savebrick;
				savebrick=nowbrick;
				nowbrick=tempbrick;
			}
		}
		//다시 그려준다.
		brick(1);
	}
	else{
		savecheck2++;
		if(savecheck2>10) return;
		if (whataround(2,nowx2,nowy2)!=0)return;
		else{
			nowytemp2=-1;
			if(savebrick2==-1){
				savebrick2=nowbrick2;
				makenewblock(2);
			}
			else{
				tempbrick2=savebrick2;
				savebrick2=nowbrick2;
				nowbrick2=tempbrick2;
			}
		}
		brick(3);
	}
	drawscreen();
}
//Gost를 그려주는 함수이다.
void CTemProject_20063703View::drawshadow(int flag)
{
	CClientDC dc(this);
	CDC MemDC;
	MemDC.CreateCompatibleDC(&dc);
	CBitmap blank,blick;
	blank.LoadBitmap(IDB_BLANK1); 
	blick.LoadBitmap(IDB_SHADOW); 
	CBitmap *pOldBitmap = (CBitmap *)MemDC.SelectObject(&blick);
	if (flag==0){
		//정당한 그림자가 아니면 리턴(홀드기능 사용시)
		if(nowytemp==-1) return;
		for (i=0;i<4;i++) {   
			MemDC.SelectObject(&blank);	
			dc.BitBlt((nowx+pat[nowbrick][nowrot*8+i*2]-1)*35+10,
				(nowytemp+pat[nowbrick][nowrot*8+i*2+1]-1)*35+10,35,35,&MemDC,0,0,SRCCOPY);
			MemDC.SelectObject(pOldBitmap);
		}
	}
	else if(flag==1){
		//현재 nowy좌표값을 nowytemp에 넣는다.
		nowytemp=nowy;
		//바닥에 닿을때까지 nowytemp를 증가시킨다.
		while(whataround(1,nowx,nowytemp+1)==0) nowytemp++;
		for (i=0;i<4;i++){
			MemDC.SelectObject(&blick);	
			dc.BitBlt((nowx+pat[nowbrick][nowrot*8+i*2]-1)*35+10,
				(nowytemp+pat[nowbrick][nowrot*8+i*2+1]-1)*35+10,35,35,&MemDC,0,0,SRCCOPY);
			MemDC.SelectObject(pOldBitmap);
		}
	}
	if (flag==2){
		if(nowytemp2==-1) return;
		for (i=0;i<4;i++) {    
			MemDC.SelectObject(&blank);	
			dc.BitBlt((nowx2+pat[nowbrick2][nowrot2*8+i*2]-1)*35+10+800,
				(nowytemp2+pat[nowbrick2][nowrot2*8+i*2+1]-1)*35+10,35,35,&MemDC,0,0,SRCCOPY);
			MemDC.SelectObject(pOldBitmap);
		}
	}
	else if(flag==3)
	{
		nowytemp2=nowy2;
		while(whataround(2,nowx2,nowytemp2+1)==0) nowytemp2++;
		
		for (i=0;i<4;i++)
		{      
			MemDC.SelectObject(&blick);	
			dc.BitBlt((nowx2+pat[nowbrick2][nowrot2*8+i*2]-1)*35+10+800,
				(nowytemp2+pat[nowbrick2][nowrot2*8+i*2+1]-1)*35+10,35,35,&MemDC,0,0,SRCCOPY);
			MemDC.SelectObject(pOldBitmap);
		}
	}
}

void CTemProject_20063703View::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	// TODO: Add your message handler code here and/or call default
	if (GameStart==FALSE)
		return;
	switch(nChar){
		//바닥까지 낙하
	case '/':
		if(GameStart2==true){
			while(downmove(2));
			PlaySound(MAKEINTRESOURCE(IDR_BLOCKDOWN),0, SND_RESOURCE | SND_ASYNC);
			makenewblock(2);
		}
		break;
		//바닥까지 낙하
	case '`':
		while(downmove(1));
		PlaySound(MAKEINTRESOURCE(IDR_BLOCKDOWN),0, SND_RESOURCE | SND_ASYNC);
		makenewblock(1);
		break;
	case 'a':
		leftmove(1);
		break;
	case 'd':
		rightmove(1);
		break;
	case 's':
		downmove(1);
		break;
	case 'w':
		rotate(1);
		PlaySound(MAKEINTRESOURCE(IDR_BLOCKTURN),0, SND_RESOURCE | SND_ASYNC);
		break;
	case 'q':
		useitem(1);
		break;
	case ';':
		useitem(2);
		break;
	}
	CView::OnChar(nChar, nRepCnt, nFlags);
}
//일시 정지하는 함수이다.
void CTemProject_20063703View::OnStop() 
{
	// TODO: Add your command handler code here
	//진행중이었다면
	if(timecheck==false)
	{
		//변수의 값을 바꿔주고
		timecheck=true;
		//타이머 해제
		KillTimer(1);
		//2Player 가 실행중이라면 타이머 해제
		if(GameStart2==true) KillTimer(2);
	}
	//정지중이었다면
	else
	{
		//변수의 값을 바꿔주고
		timecheck=false;
		//타이머 설정
		SetTimer(1,speed,NULL);
		//2Player 가 실행중이라면 타이머 설정
		if(GameStart2==true) SetTimer(2,speed2,NULL);
		//본화면을 다시 그려준다.
		drawscreen();
	}
}
//새로운 블록을 그려주는 함수이다.
void CTemProject_20063703View::makenewblock(int flag)
{
	if(flag==1){
		nowbrick=nextbrick;
		//random 함수 변경
		nextbrick=GetTickCount()%7;
		nowx=7;
		nowy=3;
		nowrot=0;    
		brick(1);
		nowytemp=-1;
		if (whataround(1,nowx,nowy)!=0) 
		{
			KillTimer(1);
			KillTimer(2);
			GameStart=FALSE;
			if(GameStart2==true){
				if(MessageBox("2 Player Win","Continue?",MB_YESNO | MB_ICONHAND)==IDYES)
					SendMessage(WM_COMMAND,ID_GAMESTART,NULL);
				else 
					EnableMenuItem(0,ID_GAMESTART,MF_BYCOMMAND | MF_ENABLED);
			}
			else{
				if(MessageBox("1 Player End","Continue?",MB_YESNO | MB_ICONHAND)==IDYES)
					SendMessage(WM_COMMAND,ID_GAMESTART,NULL);
				else 
					EnableMenuItem(0,ID_GAMESTART,MF_BYCOMMAND | MF_ENABLED);
			}
		}
	}
	else{
		nowbrick2=nextbrick2;
		nextbrick2=random(7)*GetTickCount()%7;
		nowx2=7;
		nowy2=3;
		nowrot2=0;    
		brick(3);
		nowytemp2=-1;
		if (whataround(2,nowx2,nowy2)!=0) {
			KillTimer(1);
			KillTimer(2);
			GameStart2=FALSE;
			if(MessageBox("1 Player Win","Continue?",MB_YESNO | MB_ICONHAND)==IDYES)
				SendMessage(WM_COMMAND,ID_GAMESTART,NULL);
			else 
				EnableMenuItem(0,ID_GAMESTART,MF_BYCOMMAND | MF_ENABLED);
		}
	}
	drawnextbrick();
}
//밑으로 떨어트리는 함수
int CTemProject_20063703View::downmove(int flag)
{
	if(GameStart2==false) KillTimer(2);
	if(flag==1){
		if (whataround(1,nowx,nowy+1)!=0) 
		{
			isfull(1);
			return 0;
		}
		brick(0);  
		nowy++;
		brick(1);
		return 1;
	}
	else
	{
		if (whataround(2,nowx2,nowy2+1)!=0) {
			isfull(2);
			return 0;
		}
		brick(2);  
		nowy2++;
		brick(3);
		return 1;
	}
	return 1;
}

void CTemProject_20063703View::OnGamestart2() 
{
	// TODO: Add your command handler code here
	m_SoundMgr.StopMid();
	m_SoundMgr.Music();

printscore();
	//배열을 초기화한다.
	for(i=0;i<23;i++) {
		for(j=0;j<14;j++) {
			tet[j][i]=0;
			tet2[j][i]=0;
		}
	}
	//아이템 리스트를 초기화
	for(i=0;i<20;i++){
		item[i]=0;
		item2[i]=0;
	}
	//맵을 설정한다.
	switch(map){
	case 1:
		//노멀
		for (i=0;i<23;i++)for(j=0;j<14;j++)     
			if (i>=21 || j==0 || j==13) {
				tet[j][i]=3;
				tet2[j][i]=3;
			}
			else {
				tet[j][i]=0;
				tet2[j][i]=0;
			}
			break;
	case 2:
		//랜덤
		for (i=0;i<23;i++)for(j=0;j<14;j++)   
			if (i==21 || j==0 || j==13) {
				tet[j][i]=3;
				tet2[j][i]=3;
			}
			//난수로 생겨난 곳의 블록위치를 제한한다.
			else if (i>15&&j>7){
				tet[random(20)*GetTickCount()%12+1][random(20)*GetTickCount()%7+13]=2;
				tet2[random(20)*GetTickCount()%12+1][random(20)*GetTickCount()%7+13]=2;
				
			}
			else {
				tet[j][i]=0;
				tet2[j][i]=0;
			}
			break;
	case 3:
		//이등변 삼각형
		for(i=0;i<23;i++) {
			for(j=0;j<14;j++){
				if(i>=21 || j==0 || j>=13){
					tet[j][i]=3;
					tet2[j][i]=3;
				}
				else if(j<i-8){
					tet[j][i]=2;
					tet2[j][i]=2;
				}
				else {
					tet[j][i]=0;
					tet2[j][i]=0;
				}
			}
		}
		break;
	case 5:
		//지그재그
		for(i=0;i<23;i++){
			for(j=0;j<14;j++){
				if(i>=21 || j==0 || j>=13){
					tet[j][i]=3;
					tet2[j][i]=3;
				}
				else if(i%2==0&&i>8){
					if(i%4==0&&j>4){
						tet[j][i]=2;
						tet2[j][i]=2;
					}
					else if(i%4!=0&&j<8){
						tet[j][i]=2;
						tet2[j][i]=2;
					}
					else {
						tet[j][i]=0;
						tet2[j][i]=0;
					}
				}
				else {
					tet[j][i]=0;
					tet2[j][i]=0;
				}
			}
		}
		break;
		
	case 4:
		//x
		for(i=0;i<23;i++){
			for(j=0;j<14;j++){
				if(i>=21 || j==0 || j>=13) {
					tet[j][i]=3;
					tet2[j][i]=3;
				}
				else if(j<i-4){
					if(j==i-9&&j!=1){
						tet[j][i]=2;
						tet[13-j][i]=2;
						tet[11][11]=2;
						tet[10][12]=2;
						tet[9][13]=2;
						tet2[j][i]=2;
						tet2[13-j][i]=2;
						tet2[11][11]=2;
						tet2[10][12]=2;
						tet2[9][13]=2;
					}
				}
				else{
					tet[j][i]=0;
					tet2[j][i]=0;
				}
			}
		}
		break;
	}	
	//변수 초기화
	speed=500;
	speed2=500;
	score=0;
	score2=0;
	SetTimer(1,speed,NULL);
	SetTimer(2,speed2,NULL);
	nextbrick=GetTickCount()%7;
	nextbrick2=random(7)*GetTickCount()%7;
	nowbrick=random(7)*GetTickCount()%7;
	nowbrick2=GetTickCount()%7;
	savebrick=-1;
	savebrick2=-1;
	savecheck=0;
	savecheck2=0;
	tempbrick=0;
	tempbrick2=0;
	makenewblock(1);
	makenewblock(2);
	timecheck=false;
	nowytemp=-1;
	nowytemp2=-1;
	nowitem=0;
	nowitem2=0;
	attack=0;
	attack2=0;
	
	//EnableMenuItem(GetMenu(hWnd),ID_START,MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	GameStart=TRUE;
	GameStart2=TRUE;
	drawscreen();
	InvalidateRect(NULL,TRUE);
	//	UpdateWindow();
}

void CTemProject_20063703View::OnZig() 
{
	// TODO: Add your command handler code here
	if(GameStart==true)return;
	map=5;
	drawscreen();
}

void CTemProject_20063703View::OnX() 
{
	// TODO: Add your command handler code here
	if(GameStart==true)return;
	map=4;
	drawscreen();
}

void CTemProject_20063703View::OnRandom() 
{
	// TODO: Add your command handler code here
	if(GameStart==true)return;
	map=2;
	drawscreen();
}

void CTemProject_20063703View::OnNomal() 
{
	// TODO: Add your command handler code here
	if(GameStart==true)return;
	map=1;
	drawscreen();
}

void CTemProject_20063703View::OnTry() 
{
	// TODO: Add your command handler code here
	if(GameStart==true)return;
	map=3;
	drawscreen();
}
//상대의 블록을 증가시킨다.
void CTemProject_20063703View::plus(int flag, int attack)
{
	if(flag==1){	
		if(attack>2){
			for(i=1;i<=20;i++){
				for(j=1;j<13;j++){
					tet2[j][i-1]=tet2[j][i];
				}
			}
			for(j=1;j<13;j++) if(j%2!=0) tet2[j][i-1]=10;
		}
		//지운수가 4이상이면 한줄을 더 추가시킨다.
		if(attack>3){
			for(i=1;i<=20;i++){
				for(j=1;j<13;j++){
					tet2[j][i-1]=tet2[j][i];
					//비워두어야 다음블럭을 추가시 합쳐지지않는다.
					tet2[j][i]=0;
				}
			}
			for(j=1;j<13;j++) if(j%2==0) tet2[j][i-1]=10;
		}
	}
	else{		
		if(attack>2){
			for(i=1;i<=20;i++){
				for(j=1;j<13;j++){
					tet[j][i-1]=tet[j][i];
				}
			}
			for(j=1;j<13;j++) if(j%2!=0) tet[j][i-1]=10;
		}
		if(attack>3){
			for(i=1;i<=20;i++){
				for(j=1;j<13;j++){
					tet[j][i-1]=tet[j][i];
					tet[j][i]=0;
				}
			}
			for(j=1;j<13;j++) if(j%2==0) tet[j][i-1]=10;
		}
	}	
}
//아이템을 추가하는 함수이다.
void CTemProject_20063703View::itemplus(int flag, int p)
{
	if(flag==1){
		//각각의 배열에 난수를 이용해 1/30확률로 블록이 있는곳에만 아이템을 추가한다.
		for(i=8;i<=20;i++)
			for(j=1;j<13;j++)
				if(tet[j][i]!=0) 
					if (random(30)==1)
						switch(random(7)){
						case 1:tet[j][i]=21;break;
						case 2:tet[j][i]=22;break;
						case 3:tet[j][i]=23;break;
						case 4:tet[j][i]=24;break;
						case 5:tet[j][i]=26;break;
						case 6:tet[j][i]=27;break;
						case 7:tet[j][i]=28;break;
						default: break;
					}	
	}
	else{
		for(i=8;i<=20;i++)
			for(j=1;j<13;j++)
				if(tet2[j][i]!=0)
					if(random(30)==1)
						switch(random(5)){
						case 1:tet2[j][i]=21;break;
						case 2:tet2[j][i]=22;break;
						case 3:tet2[j][i]=23;break;
						case 4:tet2[j][i]=24;break;
						case 5:tet2[j][i]=26;break;
						case 6:tet2[j][i]=27;break;
						case 7:tet2[j][i]=28;break;
						default: break;
					}			
	}
}
//사용자가 아이템을 사용하면 호출되는 함수이다.
void CTemProject_20063703View::useitem(int flag)
{
	if(flag==1){
		//아이템의 첫번째(큐)
		switch(item[0]){
			//맵을 교환한다.
		case 26:
			int tettemp[14][23];
			memcpy(tettemp,tet,sizeof(tettemp)); 
			memcpy(tet,tet2,sizeof(tet)); 
			memcpy(tet2,tettemp,sizeof(tet2)); 	
			break;
		case 0:
			return;
			//상대의 블록을 증가시킨다.
		case 21:
			plus(1,4);
			break;
			//자신의 블록을 2칸 지운다.
		case 22:
			for(i=1;i<13;i++){
			tet[i][20]=0;
			tet[i][19]=0;
			}
			for(i=20;i>0;i--){
				for(j=1;j<13;j++){
					if(tet[j][i-2]!=3){
					tet[j][i]=tet[j][i-2];
					tet[j][i-2]=0;
					}
				}
			}
					break;
			//상대의 아이템 리스트를 비운다.
		case 23:for(i=0;i<20;i++)item2[i]=0;
			nowitem2=0;break;
			//자신의 맵상태에서 반정도를 지운다.
		case 24: for(i=0;i<=12;i++)for(j=1;j<13;j++)tet[j][i]=0;break;
			//상대방의 스피드를 올린다.
		case 27:speed2-=150; break;
			//자신의 스피드를 낮춘다.
		case 28:speed+=150; break;
		}
		//아이템을 한칸씩 밀어준다.
		for(i=0;i<19;i++) item[i]=item[i+1];
		//큐
		nowitem--;
	}
	else{
		switch(item2[0]){
		case 0:
			return;
		case 26:
			int tettemp[14][23];
			memcpy(tettemp,tet,sizeof(tettemp)); 
			memcpy(tet,tet2,sizeof(tet)); 
			memcpy(tet2,tettemp,sizeof(tet2)); 
			break;
		case 21:
			plus(2,4);
			break;
		case 22:
			for(i=1;i<13;i++){
			tet2[i][20]=0;
			tet2[i][19]=0;
			}
			for(i=20;i>0;i--){
				for(j=1;j<13;j++){
					if(tet2[j][i-2]!=3){
					tet2[j][i]=tet2[j][i-2];
					tet2[j][i-2]=0;
					}
				}
			}
					break;
		case 23:for(i=0;i<20;i++)item[i]=0;nowitem=0;break;
		case 24: for(i=0;i<=12;i++)for(j=1;j<13;j++)tet2[j][i]=0;break;
		case 27:speed-=150;break;
		case 28:speed2+=150;break;
		}
		for(i=0;i<19;i++) item2[i]=item2[i+1];
		nowitem2--;
	}
	//아이템을 사용하고 나서는 그림자의 영향이 없어야 하기 때문에 변수 초기화
	nowytemp=-1;
	nowytemp2=-1;
	drawscreen();
}