downboxes.cpp

俄罗斯方块

#include "DownBoxes.h"
/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////
//DownBoxes
DownBoxes::DownBoxes()
{
	//将成员类DownBoxes所在的类纪录下来
//	this->pDownBoxGame=p;
	lBoxSize=BOXSIZE;
//	pointBasePoint.x=250;
	pointBasePoint.y=20;
	pointOffset.x=0;
	pointOffset.y=0;

}
void DownBoxes::Initialize()
{
	SetBoxOfSpecificDirection(this->lCurrentDirection);
}
void DownBoxes::SetAllBoxesPointer(CObArray *p)
//transmit DownBoxesGame's obAllBoxesArray address to  member object DownBoxes
{
	pAllBoxesArray=p;
}
void DownBoxes::SetBasePoint(POINT pointBase)
{
	this->pointBasePoint.x=pointBase.x;
	this->pointBasePoint.y=pointBase.y;
}
void DownBoxes::Draw(CDC *pDC)
{

	long lIndex=obBoxArray.GetSize();
	while(lIndex--)
		((SingleBox *)obBoxArray.GetAt(lIndex))->Draw(pDC);

}
long DownBoxes::GetCurrentDirection()
{
	return this->lCurrentDirection;
}
void DownBoxes::Move(long lDx,long lDy)
//lDx,lDy 's unit is BOXSIZE
{
	long lBoxCount=obBoxArray.GetSize();
	pointOffset.x+=lDx;
	pointOffset.y+=lDy;
	while (lBoxCount--)
		((SingleBox*)obBoxArray.GetAt(lBoxCount))->MoveBox(lDx,lDy);

}
long DownBoxes::IsCanDown()
{
	long lBoxesGroup,lBoxIndex,lCurrentBoxIndex;
	DownBoxes *p;
	lBoxesGroup=this->pAllBoxesArray->GetSize();

	while(lBoxesGroup--)
	{
		p=(DownBoxes *)pAllBoxesArray->GetAt(lBoxesGroup);
		lBoxIndex=p->obBoxArray.GetSize();
		while(lBoxIndex--)
		{
			((DownBoxes *)pAllBoxesArray->GetAt(lBoxesGroup));
			this->MoveDown();
			lCurrentBoxIndex=this->obBoxArray.GetSize();
			while(lCurrentBoxIndex--)
				if(IsOverlappedSingleBox((SingleBox *)obBoxArray.GetAt(lCurrentBoxIndex),(SingleBox *)p->obBoxArray.GetAt(lBoxIndex))==0)	
					return 0;

		}
	}
	return 1;
}
long DownBoxes::IsOverlappedSingleBox(SingleBox * pA,SingleBox * pB)
{
	if (pA->GetBoxBorder()->bottom==pB->GetBoxBorder()->bottom &&
		pA->GetBoxBorder()->left  ==pB->GetBoxBorder()->left   &&
		pA->GetBoxBorder()->right ==pB->GetBoxBorder()->right  &&
		pA->GetBoxBorder()->top   ==pB->GetBoxBorder()->top    )
		return 1;
	else 
		return 0;

}
CObArray * DownBoxes::GetObArray()
{
	return &obBoxArray;
}
void DownBoxes::MoveLeft()
{
	Move(-1,0);
}
void DownBoxes::MoveRight()
{
	Move(1,0);
}
void DownBoxes::MoveDown()
{
	Move(0,1);
}
void DownBoxes::MoveUp()
{
	Move(0,-1);
}
void DownBoxes::SetSingleBox(long lIndex,long lLeft,long lTop)
//All the for values: lLeft...lBottom, are offset value
{	
	CRect rectBoxBorder;
	SingleBox * pSingleBox;
	pSingleBox=(SingleBox *)obBoxArray.GetAt(lIndex);
	rectBoxBorder.top   =pointBasePoint.y+lTop;
	rectBoxBorder.bottom=rectBoxBorder.top+lBoxSize;
	rectBoxBorder.left  =pointBasePoint.x+lLeft;
	rectBoxBorder.right =rectBoxBorder.left+lBoxSize;
	pSingleBox->SetBoxBorder( rectBoxBorder);
}
//////////////////////////////////////////////////
//////////////////////////////////////////////////
//Member functions of SingleBox class
SingleBox::SingleBox()
{
	lBoxSize=BOXSIZE;
}
SingleBox::SingleBox(RECT & rectBorder)
{
	lBoxSize=BOXSIZE;
	rectBoxBorder.bottom =rectBorder.bottom ;
	rectBoxBorder.left =rectBorder.left ;
	rectBoxBorder.right=rectBorder.right;
	rectBoxBorder.top =rectBorder.top ;
}
void SingleBox::Draw(CDC * pDC)
{
	pDC->Rectangle(&rectBoxBorder); 
}
void SingleBox::SetBoxBorder(RECT &rectBorder) 
{
	rectBoxBorder.bottom =rectBorder.bottom ;
	rectBoxBorder.left =rectBorder.left ;
	rectBoxBorder.right=rectBorder.right;
	rectBoxBorder.top =rectBorder.top ;
}
void SingleBox::Erase(CDC *pDC)
{

}
void SingleBox::MoveBox(long lDx,long lDy)
{
	rectBoxBorder.left=rectBoxBorder.left+lDx*lBoxSize;
	rectBoxBorder.right=rectBoxBorder.left+lBoxSize;
	rectBoxBorder.top=rectBoxBorder.top+lDy*lBoxSize;
	rectBoxBorder.bottom=rectBoxBorder.top+lBoxSize;
}
RECT *SingleBox::GetBoxBorder()
{
	return &rectBoxBorder;
}
//////////////////////////////////////////////////
//////////////////////////////////////////////////
//Member functions of DownBoxes1 class

DownBoxes1::DownBoxes1():DownBoxes()
{
	this->lShapeType =1;
	srand( (unsigned)time( NULL ) ); 
	this->lCurrentDirection=rand()%4+1;
	long lBoxCount=0 ;
	while (lBoxCount++<4)
		obBoxArray.Add(new SingleBox());

}



void DownBoxes1::ClockWiseRotation()
{
	this->SetBoxOfSpecificDirection(lCurrentDirection%4+1);
	switch(lCurrentDirection)
	{
	case 1:
		Move(-1,1);
		break;
	case 2:
		Move(1,-1);
		break;
	case 3:
		Move(-1,1);
		break;
	case 4:
		Move(1,-1);
		break;
	}
	lCurrentDirection=lCurrentDirection%4+1;
} 
void DownBoxes1::SetBoxOfSpecificDirection(long lDirection)
{

	long lBoxCount=obBoxArray.GetSize();
	long lOffsetX=pointOffset.x*lBoxSize,lOffsetY=pointOffset.y*lBoxSize;
	switch (lDirection)
	{
	case 1:
		while(lBoxCount--) SetSingleBox(lBoxCount,lOffsetX+0,lOffsetY+lBoxCount*lBoxSize);
		break;
	case 2:
		while(lBoxCount--) SetSingleBox(lBoxCount,lOffsetX+lBoxCount*lBoxSize,lOffsetY+0);
		break;
	case 3:
		while(lBoxCount--) SetSingleBox(lBoxCount,lOffsetX+0,lOffsetY+lBoxCount*lBoxSize);
		break;
	case 4:
		while(lBoxCount--) SetSingleBox(lBoxCount,lOffsetX+lBoxCount*lBoxSize,lOffsetY+0);
		break;
	}

}
void DownBoxes1::CounterClockWiseRotation()
{
}

//////////////////////////////////////////////////
//////////////////////////////////////////////////
//Member functions of DownBoxes2 class

DownBoxes2::DownBoxes2():DownBoxes()
{
	this->lShapeType =2;
	srand((unsigned)time(NULL)); 
	this->lCurrentDirection=rand()%4+1;
	long lBoxCount=0 ;
	while (lBoxCount++<4)
		obBoxArray.Add(new SingleBox());

}
void DownBoxes2::SetBoxOfSpecificDirection(long lDirection)
{
	long lBoxCount=obBoxArray.GetSize();
	lBoxCount--;

	long lOffsetX=pointOffset.x*lBoxSize,lOffsetY=pointOffset.y*lBoxSize;
	switch (lDirection)
	{
	case 4:
		while(lBoxCount--) SetSingleBox(lBoxCount,lOffsetX+0,lOffsetY+lBoxCount*lBoxSize);
		SetSingleBox(3,lOffsetX+lBoxSize,lOffsetY+lBoxSize*2);
		break;
	case 3:
		while(lBoxCount--) SetSingleBox(lBoxCount,lOffsetX+lBoxCount*lBoxSize,lOffsetY+lBoxSize);
		SetSingleBox(3,lOffsetX+2*lBoxSize,lOffsetY+0);
		break;
	case 2:
		while(lBoxCount--) SetSingleBox(lBoxCount,lOffsetX+lBoxSize,lOffsetY+lBoxCount*lBoxSize);
		SetSingleBox(3,lOffsetX+0,lOffsetY+0);
		break;
	case 1:
		while(lBoxCount--) SetSingleBox(lBoxCount,lOffsetX+lBoxCount*lBoxSize,lOffsetY+0);
		SetSingleBox(3,lOffsetX+0,lOffsetY+lBoxSize);
		break;
	}

}

void DownBoxes2::ClockWiseRotation()
{
	this->SetBoxOfSpecificDirection(lCurrentDirection%4+1);
	switch(lCurrentDirection)
	{
	case 1:
		Move(0,0);
		break;
	case 2:
		Move(0,0);
		break;
	case 3:
		Move(0,0);
		break;
	case 4:
		Move(0,0);
		break;
	}
	lCurrentDirection=lCurrentDirection%4+1;
} 
void DownBoxes2::CounterClockWiseRotation()
{
}
//////////////////////////////////////////////////
//////////////////////////////////////////////////
//Member functions of BoxGame class
DownBoxes *DownBoxesGame::CreateRandomBoxes()
{
	DownBoxes *p;
	POINT pointBase;
	pointBase.x=this->rectPlayArea.left+(long)(((rectPlayArea.right-rectPlayArea.left)/BOXSIZE/2)-2)*BOXSIZE+1;
	pointBase.y=this->rectPlayArea.top+1;
	srand( (unsigned)time(NULL)); 
	long lRandomType=rand()%TYPE_COUNT+1;
	switch(lRandomType)
	{
	case 1:
		p=new DownBoxes1();
		break;
	case 2:
		p=new DownBoxes2();
		break;
/*	case 3:
		p=new DownBoxes2();
		break;
	case 4:
		p=new DownBoxes2();
		break;
	case 5:
		p=new DownBoxes2();
		break;
	case 6:
		p=new DownBoxes2();
		break;*/
	}
	p->SetBasePoint(pointBase);
	return p;
}
DownBoxesGame::DownBoxesGame()
{
	this->SetFrame();//设置基本区域边界信息，是画图的基础信息
	pDownBoxes=CreateRandomBoxes();	
	obAllBoxesArray.Add(pDownBoxes);
	pDownBoxes->Initialize();
	pDownBoxes->SetAllBoxesPointer(&obAllBoxesArray);
}
void DownBoxesGame::OnTimer(UINT nIDEvent)
{
//	pDownBoxes=CreateRandomBoxes();	
	this->GetDownBoxes()->MoveDown();
//	pDownBoxes->Initialize();	
}

void DownBoxesGame::Draw(CDC *pDC)
{
	DrawFrame(pDC);
	this->GetDownBoxes()->Draw(pDC);
}
void DownBoxesGame::DrawFrame(CDC *pDC)
{
	pDC->Rectangle(&rectBirthArea);
	pDC->Rectangle(&rectPlayArea);
}
void DownBoxesGame::SetFrame()
{
	rectBirthArea.left=200;
	rectBirthArea.top=20;
	rectBirthArea.right=rectBirthArea.left+(BOXSIZE+1)*15+3;
	rectBirthArea.bottom=rectBirthArea.top+(BOXSIZE+1)*5+3;
	
	rectPlayArea.left=200;
	rectPlayArea.top=rectBirthArea.bottom+1;
	rectPlayArea.right=rectPlayArea.left+(BOXSIZE+1)*15+3;
	rectPlayArea.bottom=rectPlayArea.top+(BOXSIZE+1)*20+3;

}
DownBoxes * DownBoxesGame::GetDownBoxes()
{
	return pDownBoxes;
}
long DownBoxesGame::IsOverFrame(DownBoxes * pDownBoxes)
//1:越界
{
	long lBoxIndex;
	SingleBox *pMed;
	lBoxIndex=pDownBoxes->GetObArray()->GetSize();
	while (lBoxIndex--)
	{
		pMed=(SingleBox *)pDownBoxes->GetObArray()->GetAt(lBoxIndex);
		if(rectPlayArea.bottom>=pMed->GetBoxBorder()->bottom && rectPlayArea.bottom<=pMed->GetBoxBorder()->top )
			return 1;
	}
	return 0;

}