tetriscontrol.cpp

自己写的俄罗斯方块

			m_nCurScore += m_nScoreLevel[m_nCurDelFloors - 1];
		if(m_nHighestBlock - m_nCurDelFloors + m_nFloorsBuffer > VERTICAL_BLOCKS_NUMBER)
		{
			m_bIsGameOver = TRUE;
			m_bIsWillFix = FALSE;
		}
		else
		{
		}
		return m_nCurDelFloors;
	}
	else
	{
		m_CurShape.m_ptPos.y++;
		return -1;
	}
}

BOOL CTetrisControl::CreateNewShape()
{
	// finished the last time operation
	if(m_nCurDelFloors > 0)
		DeleteFloors();
	if(m_nFloorsBuffer > 0)
		AddFloors();

	m_CurShape = m_NextShape;
	m_nCurShapeType = m_nNextShapeType;
	m_nCurShapeDir = m_nNextShapeDir;
	CreateShape();
	int x, y;
	for(int i = 0; i < m_CurShape.m_bBlocks; i++)
	{
		x = m_CurShape.m_ptPos.x + WALL_THICKNESS + m_CurShape.m_ptBlocks[i].x;
		y = m_CurShape.m_ptPos.y + WALL_THICKNESS + m_CurShape.m_ptBlocks[i].y;
		if(m_Blocks[x][y].m_nStatus == HAVE_BLOCK)
		{
			m_bIsGameOver = TRUE;
			FixCurShape();
			return FALSE;
		}
	}
	return TRUE;
}

int CTetrisControl::OnSmoothDown(float fSmoothInc)
{
	int nResult = -1;
	m_fSmoothDown += fSmoothInc;
	if(m_fSmoothDown > 1)
	{
		nResult = OnDown();
		m_fSmoothDown -= 1;
		if(nResult > -1)
			m_fSmoothDown = 0;
	}
	return nResult;
}

int CTetrisControl::OnDownToBottom()
{
	int nResult;
	while((nResult = OnDown()) == -1);
	m_fSmoothDown = 0;
	return nResult;
}

void CTetrisControl::FixCurShape()
{
	if(m_bIsWillFix)
	{
		int x, y;
		for(int i = 0; i < m_CurShape.m_bBlocks; i++)
		{
			x = m_CurShape.m_ptPos.x + WALL_THICKNESS + m_CurShape.m_ptBlocks[i].x;
			y = m_CurShape.m_ptPos.y + WALL_THICKNESS + m_CurShape.m_ptBlocks[i].y;
			m_Blocks[x][y].m_nStatus = HAVE_BLOCK;
			m_Blocks[x][y].m_nColor = m_CurShape.m_nColor;
			m_Blocks[x][y].m_nStyle = int(rand()*32/RAND_MAX);
			m_nCurBlocksInFloor[VERTICAL_BLOCKS_NUMBER + WALL_THICKNESS - 1 - y]++;
			if(VERTICAL_BLOCKS_NUMBER + WALL_THICKNESS - y > m_nHighestBlock)
				m_nHighestBlock = VERTICAL_BLOCKS_NUMBER + WALL_THICKNESS - y;
		}
	}
	else
		m_bIsWillFix = TRUE;
}

int CTetrisControl::CalcDeletedFloors()
{
	int nDelFloors = 0;
	for(int i = 0; i < m_CurShape.m_bBlocks; i++)
	{
		int y = m_CurShape.m_ptPos.y + WALL_THICKNESS + m_CurShape.m_ptBlocks[i].y;
		if(m_nCurBlocksInFloor[VERTICAL_BLOCKS_NUMBER + WALL_THICKNESS - 1 - y] == HORIZONTAL_BLOCKS_NUMBER)
		// the current floor is full
		{
			// save the index (y-coordiate) of the floor
			for(int j = 0; j < BLOCKS_IN_SHAPE; j++)
			{
				// the floor existed, don't save anymore
				if(m_nCramedFloors[j] == (y - WALL_THICKNESS))
					break;
			}
			if(j == BLOCKS_IN_SHAPE)
			{
				nDelFloors++;
				for(j = 0; j < nDelFloors; j++)
					if(m_nCramedFloors[j] < (y - WALL_THICKNESS))
					{
						for(int k = nDelFloors - 1; k > j ; k--)
							m_nCramedFloors[k] = m_nCramedFloors[k - 1];
						m_nCramedFloors[j] = y - WALL_THICKNESS;
						break;
					}
			}
		}
	}
	return nDelFloors;
}

void CTetrisControl::DeleteFloors()
{
	// delete floors 
	int nDelCounter = 0;
	for(int i = 0; i < BLOCKS_IN_SHAPE; i++)
		if(m_nCramedFloors[i] != -1)
		{
			for(int k = WALL_THICKNESS; k < HORIZONTAL_BLOCKS_NUMBER + WALL_THICKNESS; k++)
				m_Blocks[k][m_nCramedFloors[i] + WALL_THICKNESS].m_nStatus = NO_BLOCK;
			m_nCurBlocksInFloor[VERTICAL_BLOCKS_NUMBER - 1 - m_nCramedFloors[i]] = 0;
			nDelCounter--;
		}
	// move the remaining floors
	for(i = VERTICAL_BLOCKS_NUMBER - 1;
		i > VERTICAL_BLOCKS_NUMBER - 1 - m_nHighestBlock; i--)
	{
		for(int j = 0; j < BLOCKS_IN_SHAPE; j++)
			if(m_nCramedFloors[j] <= i)
				break;
		if(j > 0)
		{
			for(int k = WALL_THICKNESS; k < HORIZONTAL_BLOCKS_NUMBER + WALL_THICKNESS; k++)
			{
				m_Blocks[k][i + j + WALL_THICKNESS] = m_Blocks[k][i + WALL_THICKNESS];
				m_Blocks[k][i + WALL_THICKNESS].m_nStatus = NO_BLOCK;
			}
			m_nCurBlocksInFloor[VERTICAL_BLOCKS_NUMBER - 1 - i - j]
				= m_nCurBlocksInFloor[VERTICAL_BLOCKS_NUMBER - 1 - i];
			m_nCurBlocksInFloor[VERTICAL_BLOCKS_NUMBER - 1 - i] = 0;
		}
	}
	// reset the m_nCramedFloors array
	for(i = 0; i < BLOCKS_IN_SHAPE; i++)
		m_nCramedFloors[i] = -1;
	m_nHighestBlock += nDelCounter;
	m_nCurDelFloors = 0;
}

int CTetrisControl::AddFloorsBuffer(int nAdd)
{
	m_nFloorsBuffer += nAdd;
	return m_nFloorsBuffer;
}

void CTetrisControl::AddFloors()
{
	// find the start floor to move
	int nStart;
	if(m_nFloorsBuffer + m_nHighestBlock > VERTICAL_BLOCKS_NUMBER)
		nStart = m_nFloorsBuffer + WALL_THICKNESS;
	else
		nStart = VERTICAL_BLOCKS_NUMBER - m_nHighestBlock + WALL_THICKNESS;
	// move the remaining floors;
	for(int i = nStart; i < VERTICAL_BLOCKS_NUMBER + WALL_THICKNESS; i++)
		for(int j = WALL_THICKNESS; j < HORIZONTAL_BLOCKS_NUMBER + WALL_THICKNESS; j++)
		{
			m_Blocks[j][i - m_nFloorsBuffer] = m_Blocks[j][i];
			m_nCurBlocksInFloor[VERTICAL_BLOCKS_NUMBER + WALL_THICKNESS - 1 - i + m_nFloorsBuffer]
				= m_nCurBlocksInFloor[VERTICAL_BLOCKS_NUMBER + WALL_THICKNESS - 1 - i];
		}
	// add new floors from the bottom
	BYTE nStatus;
	for(int j = 0; j < m_nFloorsBuffer; j++)
	{
		CalcBlocksStatusInFloor();
		m_nCurBlocksInFloor[j] = 0;
		for(int i = WALL_THICKNESS; i < HORIZONTAL_BLOCKS_NUMBER + WALL_THICKNESS; i ++)
		{
			// choose a existence status randomly
			if((nStatus = m_bBlocksStatusInFloor[i - WALL_THICKNESS])== HAVE_BLOCK)
				m_nCurBlocksInFloor[j]++;
			m_Blocks[i][VERTICAL_BLOCKS_NUMBER + WALL_THICKNESS - 1 - j].m_nStatus = nStatus;
			// choose a color randomly
			m_nBlockSeed = Rand(m_nBlockSeed);
			m_Blocks[i][VERTICAL_BLOCKS_NUMBER + WALL_THICKNESS - 1 - j].m_nColor = 
				m_nBlockSeed * m_nBlockColorsNum / OWN_RAND_MAX;
			m_Blocks[i][VERTICAL_BLOCKS_NUMBER + WALL_THICKNESS - 1 - j].m_nStyle = 
				int(rand()*32/RAND_MAX);
		}
	}
	m_nHighestBlock += m_nFloorsBuffer;
	m_nFloorsBuffer = 0;
}

void CTetrisControl::CalcBlocksStatusInFloor()
{
	for(int i = 0; i < HORIZONTAL_BLOCKS_NUMBER; i++)
		m_bBlocksStatusInFloor[i] = HAVE_BLOCK;
	m_nBlockSeed = Rand(m_nBlockSeed);
	int nNoBlockNum = MIN_NO_BLOCK_NUMBER + (MAX_NO_BLOCK_NUMBER - MIN_NO_BLOCK_NUMBER + 1)
		* m_nBlockSeed / OWN_RAND_MAX;
	int nPos;
	for(i = 0; i < nNoBlockNum; i++)
	{
		m_nBlockSeed = Rand(m_nBlockSeed);
		nPos = HORIZONTAL_BLOCKS_NUMBER * m_nBlockSeed / OWN_RAND_MAX;
		m_bBlocksStatusInFloor[nPos] = NO_BLOCK;
	}
}

int CTetrisControl::Rand(int nSeed, int nMax)
{
	return	(nSeed*25173+13849) % nMax;
}

////////////////////////////////////////////////////////

CBlock::CBlock(BYTE nStatus,BYTE nColor, BYTE nStyle)
{
	m_nStatus = nStatus;
	m_nColor = nColor;
	m_nStyle = nStyle;
}

void CBlock::operator = (const CBlock& block)
{
	m_nStatus = block.m_nStatus;
	m_nColor = block.m_nColor;
	m_nStyle = block.m_nStyle;
}

////////////////////////////////////////////////////////

CBasicShape::CBasicShape()
{
	for(int i = 0; i < BLOCKS_IN_SHAPE; i++)
		m_ptBlocks[i] = CPoint(-BLOCKS_IN_SHAPE, -BLOCKS_IN_SHAPE);
	m_bBlocks = 0;
}

void CBasicShape::operator = (const CBasicShape& shape)
{
	for(int i = 0; i < BLOCKS_IN_SHAPE; i++)
		m_ptBlocks[i] = shape.m_ptBlocks[i];
	m_bBlocks = shape.m_bBlocks;
}

BOOL CBasicShape::operator == (const CBasicShape& shape)
{
	BOOL bResult = TRUE;
	for(int i = 0; i < BLOCKS_IN_SHAPE; i++)
		if(m_ptBlocks[i] != shape.m_ptBlocks[i])
			return FALSE;
	return bResult;
}

////////////////////////////////////////////////////////

CShape::CShape()
{
	CBasicShape::CBasicShape();
	m_nColor = 0;
	m_ptPos = CPoint(0, 0);
}

void CShape::operator = (const CShape& shape)
{
	for(int i = 0; i < BLOCKS_IN_SHAPE; i++)
		m_ptBlocks[i] = shape.m_ptBlocks[i];
	m_bBlocks = shape.m_bBlocks;
	m_nColor = shape.m_nColor;
	m_ptPos = shape.m_ptPos;
}

void CShape::operator = (const CBasicShape& shape)
{
	for(int i = 0; i < BLOCKS_IN_SHAPE; i++)
		m_ptBlocks[i] = shape.m_ptBlocks[i];
	m_bBlocks = shape.m_bBlocks;
}