tetris_game.cpp

自己写的俄罗斯方块

	{
		Blt3D(LevelRect.x, LevelRect.y, m_Texture_Level, LevelNumberRect+1);
		Blt3D(LevelRect.x + LEVEL_WIDTH, LevelRect.y, m_Texture_Level, LevelNumberRect);
	}
/**************/

	return S_OK;
}

int CTetris_Game::PlayerInputNotify(int player, int nkeydef, int defaultrow)
{
	int row=defaultrow;
	BOOL res;
	if(TetrisEngine[player].IsGameOver()||m_Explode[player]!=EFFECT_NOT_START||m_AddFloor[player]!=EFFECT_NOT_START)
		return row;

	switch(nkeydef)
	{
	case KeyDef_Left://左
		if(TetrisEngine[player].OnLeft())
			PlayTetrisSound(player, SOUND_MOVE);
		else
			PlayTetrisSound(player, SOUND_INVALID);
		break;
	case KeyDef_Right://右
		if(TetrisEngine[player].OnRight())
			PlayTetrisSound(player, SOUND_MOVE);
		else
			PlayTetrisSound(player, SOUND_INVALID);
		break;
	case KeyDef_Rotate://旋转
		if(m_smoothrotate)
			res = TetrisEngine[player].OnStartSmoothRotate();
		else
			res = TetrisEngine[player].OnRotate();
		if(res)
			PlayTetrisSound(player, SOUND_ROTATE);
		else
			PlayTetrisSound(player, SOUND_INVALID);
		break;
	case KeyDef_Bottom://底
		row=TetrisEngine[player].OnDownToBottom();
		break;
	case KeyDef_Down://下一层
		if(m_smoothdown)
			row=TetrisEngine[player].OnSmoothDown((float)ANIME_TIME/ACCE_DOWNSPEED);
		else
			row=TetrisEngine[player].OnDown();
		break;
	case KeyDef_SmoothDown://平滑下一层
		row=TetrisEngine[player].OnSmoothDown((float)ANIME_TIME/TimerInterval[m_curLevel]);
		break;
	case KeyDef_SmoothRotate://平滑旋转
		TetrisEngine[player].OnSmoothRotate((float)ANIME_TIME/ROTATE_TIME);
		break;
	default:;
	}
	return row;
}

void CTetris_Game::NewGame()
{
	StopAllSubtitle();
	LastTime_Down[0]=LastTime_Down[1]=timeGetTime();
	m_curLevel=m_Level;
	m_Explode[0]=m_Explode[1]=EFFECT_NOT_START;
	m_AddFloor[0]=m_AddFloor[1]=EFFECT_NOT_START;
	m_DisplayScore[0]=m_DisplayScore[1]=0;
	m_nAddFloorBuffer[0]=m_nAddFloorBuffer[1]=0;
	m_nAddingFloor[0]=m_nAddingFloor[1]=0;
	int seed=rand(), i, p;
	for(i=0;i<MAX_PLAYER;i++)
		m_bWindowRendering[i] = TRUE;
	switch(playernumber)
	{
	case 1:
		if(m_leftwindow)
			m_bWindowRendering[1] = FALSE;
		else
			m_bWindowRendering[0] = FALSE;
		break;
	case 2:
		TetrisEngine[0].SetComputerPlay(false);
		TetrisEngine[1].SetComputerPlay(false);
		break;
	case 3:
		if(m_leftwindow)
		{
			TetrisEngine[0].SetComputerPlay(false);
			TetrisEngine[1].SetComputerPlay(true, m_AILevel);
		}
		else
		{
			TetrisEngine[0].SetComputerPlay(true, m_AILevel);
			TetrisEngine[1].SetComputerPlay(false);
		}
		break;
	}

	PlayTetrisMusic(MUSIC_LEVEL00 + m_curLevel);

	for(p=0;p<MAX_PLAYER;p++)	if(m_bWindowRendering[p])
	{
		TetrisEngine[p].SetInitFloors(m_difficulty);
		TetrisEngine[p].Start(seed);
	}
	AnimeFrame=0;
	m_bIsPaused=FALSE;
	m_bIsPlaying=TRUE;
}

void CTetris_Game::StopGame(BOOL ChangeSound)
{
	StopAllSubtitle();
	if(ChangeSound)
		PlayTetrisMusic(MUSIC_LEVEL00);
	m_bWindowRendering[0]=m_bWindowRendering[1]=FALSE;
	m_bIsPaused = FALSE;
	m_bIsPlaying=FALSE;
	Render();
}

void CTetris_Game::PauseGame()
{
	if(m_bIsPlaying)
	{
		m_bIsPaused = TRUE;
		Render();
	}
}

void CTetris_Game::PlayTetrisSound(int player, int nsound)
{
	if(m_bPlaySound&&nsound<MAX_SOUND&&g_pSound[nsound])
		g_pSound[nsound]->Play( DMUS_SEGF_DEFAULT | DMUS_SEGF_SECONDARY, g_p3DAudiopath );
}

void CTetris_Game::PlayTetrisMusic(int nmusic)
{
//	StopTetrisMusic();
	if(m_bPlayMusic&&nmusic<MAX_MUSIC&&g_pMusic[nmusic])
	{
		g_pMusic[nmusic]->Play( DMUS_SEGF_DEFAULT, g_p3DAudiopath );
	}
}

void CTetris_Game::StopTetrisMusic()
{
	for(int i=0;i<MAX_MUSIC;i++)
		if(g_pMusic[i]&&g_pMusic[i]->IsPlaying())
			g_pMusic[i]->Stop();

}

void CTetris_Game::UpdateRect()
{
	if(m_pd3dDevice)
		Render();
}

void CTetris_Game::Animate(KeyStatus keystatus[MAX_PLAYER][MAX_KEYDEF], DWORD curTime)
{if(m_bWindowRendering[0]||m_bWindowRendering[1]){//至少有一个窗口需要Render

	DWORD interval;
	int p;
	int row[MAX_PLAYER]={-1, -1};//该状态为平常状态
	if(m_bIsPlaying)
	{
		EACH_PLAYER(p)	if(m_Explode[p]==EFFECT_NOT_START&&m_AddFloor[p]==EFFECT_NOT_START)
		{
			switch(TetrisEngine[p].ComputerPlay())//AI control/action execute
			{
			case ComputerMove_None:
				break;
			case ComputerMove_Left:
				row[p] = PlayerInputNotify(p, KeyDef_Left, row[p]);
				break;
			case ComputerMove_Right:
				row[p] = PlayerInputNotify(p, KeyDef_Right, row[p]);
				break;
			case ComputerMove_Rotate:
				row[p] = PlayerInputNotify(p, KeyDef_Rotate, row[p]);
				break;
			case ComputerMove_Bottom:
				row[p] = PlayerInputNotify(p, KeyDef_Bottom, row[p]);
				break;
			case ComputerMove_Down:
				row[p] = PlayerInputNotify(p, KeyDef_Down, row[p]);
				break;
			default:;
			}
			if(row[p]==-1)
				for(DWORD j = 0; j < MAX_KEYDEF; j++ ) 
				{
					if(keystatus[p][j].bKeyPress)
					{
						row[p]=PlayerInputNotify(p, j, row[p]);
						if(j==KeyDef_Down)
							PlayTetrisSound(p, SOUND_SPEEDUP);
					}
					/*****KEYDOWN REPEAT*******/
					if(keystatus[p][j].bKeydown&&j<2)
					{
						interval=curTime-keystatus[p][j].DownTime;
						if(interval > KEY_REPEAT_INTERVAL)
						{
							keystatus[p][j].DownTime+=interval/KEY_REPEAT_INTERVAL*KEY_REPEAT_INTERVAL;
							row[p] = PlayerInputNotify(p, j, row[p]);
						}
					}
				}
			/*****ID_GAME_TIMER*******/
			if(row[p]==-1)
			{
				if(m_smoothrotate)
					PlayerInputNotify(p, KeyDef_SmoothRotate);//系统要求的旋转

				interval=curTime-LastTime_Down[p];
				if(m_smoothdown)
				{
					if(keystatus[p][KeyDef_Down].bKeydown)
					{
						row[p]=PlayerInputNotify(p, KeyDef_Down, row[p]);//系统要求的下降
					}
					else
						row[p]=PlayerInputNotify(p, KeyDef_SmoothDown, row[p]);//系统要求的下降
				}
				else
				{
					if(keystatus[p][KeyDef_Down].bKeydown)
					{
						if(interval>ACCE_DOWNSPEED)
						{
							LastTime_Down[p]+=interval/ACCE_DOWNSPEED*ACCE_DOWNSPEED;
							row[p]=PlayerInputNotify(p, KeyDef_Down, row[p]);
						}
					}
					else
					{
						if(interval>TimerInterval[m_curLevel])
						{
							LastTime_Down[p]+=interval/TimerInterval[m_curLevel]*TimerInterval[m_curLevel];
							row[p]=PlayerInputNotify(p, KeyDef_Down, row[p]);
						}
					}
				}
			}
			if(row[p]!=-1)//如果方块放下，键 repeat取消
			{
				keystatus[p][0].bKeydown = FALSE;
				keystatus[p][1].bKeydown = FALSE;
				keystatus[p][3].bKeydown = FALSE;
				keystatus[p][4].bKeydown = FALSE;
			}
		}

		/*****判断分数是否够升级*******/
		EACH_PLAYER(p) if(playernumber==1&&TetrisEngine[p].GetCurScore()/LEVELUP_SCORE+m_Level>m_curLevel)
		{
			if(m_curLevel<MAX_LEVEL)//升级
			{
				AddSubtitle(p, m_curLevel+Subtitle_Draw);
				m_curLevel++;
				PlayTetrisMusic(MUSIC_LEVEL00 + m_curLevel);
				PlayTetrisSound(p, SOUND_LEVELUP);
			}
			else//通关
			{
				TetrisEngine[p].CreateNewShape();
				AddSubtitle(p, Subtitle_Win, 3*SUBTITLE_TIME2);
				PlayTetrisSound(p, SOUND_LEVELCLEAR);
				PlayTetrisMusic(MUSIC_LEVEL00);
				m_GameOver_Counter[p] = 0;
				m_bIsPaused	= FALSE;
				m_bIsPlaying= FALSE;
			}
		}
		/*****判断是否需要开启爆炸或者增长等效果*******/

		EACH_PLAYER(p)	if(row[p]>=0)//如果接触地面
			PlayTetrisSound(p, SOUND_BOTTOM);

		EACH_PLAYER(p)	if(row[p]>0)//爆炸开始
		{
			if(row[p]>1)
				m_nAddFloorBuffer[1-p]+=row[p];
			if(m_othereffect)
				m_Explode[p]=EFFECT_START;
			else
			{
				m_Explode[p]=DELLINE_TIME;
				PlayTetrisSound(p, SOUND_DELLINE);
			}
		}

		EACH_PLAYER(p)
			if(m_Explode[p]>=DELLINE_TIME||row[p]==0)	//爆炸完毕或者落地
			{
				if(TetrisEngine[p].GetFloorsBuffer()>0)	//如果有需要加的行
				{
					if(m_othereffect)
					{
						m_nAddingFloor[p]=TetrisEngine[p].GetFloorsBuffer();
						if(m_nAddingFloor[p]>VERTICAL_BLOCKS_NUMBER)
							m_nAddingFloor[p]=VERTICAL_BLOCKS_NUMBER;

						m_AddFloor[p]=EFFECT_START;
						PlayTetrisSound(p, SOUND_ADDLINE);
					}
				}
				TetrisEngine[p].CreateNewShape();
			}

		EACH_PLAYER(p)
			if(m_Explode[p]>=DELLINE_TIME)//爆炸完毕给对方加行
				if(m_nAddFloorBuffer[1-p]>0)
				{
					TetrisEngine[1-p].AddFloorsBuffer(m_nAddFloorBuffer[1-p]);
					m_nAddFloorBuffer[1-p]=0;
				}

		EACH_PLAYER(p)	if(m_Explode[p]==CHANGEWHITE_FRAME+1)//爆炸音效
			PlayTetrisSound(p, SOUND_DELLINE);

		EACH_PLAYER(p)	if(m_Explode[p]==EFFECT_NOT_START&&m_AddFloor[p]==EFFECT_NOT_START)
			TestGameOver(p);

		EACH_PLAYER(p)
		{
			if(m_Explode[p]>=DELLINE_TIME)
				m_Explode[p]=EFFECT_NOT_START;
			if(m_AddFloor[p]>=ADDFLOOR_FRAME*m_nAddingFloor[p])//增加行完毕
			{
				m_AddFloor[p]=EFFECT_NOT_START;
				m_nAddingFloor[p]=0;
			}
		}
	}

	/*****ANIME TIMER*******/
	AnimeFrame=(AnimeFrame+1)%10000;
	Render();

	if(m_bIsPlaying)
		EACH_PLAYER(p)
		{
			if(m_Explode[p]!=EFFECT_NOT_START)//爆炸动画
				m_Explode[p]++;

			if(m_AddFloor[p]!=EFFECT_NOT_START)//增加行动画
				m_AddFloor[p]++;
		}

}}

void CTetris_Game::AddSubtitle(int player, int sub, int subtime)
{
	if(sub>=SUBTITLE_NUMBER)
		return;
	for(int i=0;i<MAX_SUBTITLE;i++)
		if(Subtitle[i].subcount==0)
			break;
	if(i<MAX_SUBTITLE)//可以显示
	{
		Subtitle[i].player=player;
		Subtitle[i].subtitle=sub;
		Subtitle[i].subcount=1;
		Subtitle[i].subtime=subtime;
	}
}

void CTetris_Game::SetMusicOn(BOOL bOn)	
{
	m_bPlayMusic = bOn;
	if(m_hWnd==0)
		return;
	if(m_bPlayMusic)
	{
		if(m_bWindowRendering[0]||m_bWindowRendering[1])
			PlayTetrisMusic(MUSIC_LEVEL00 + m_curLevel);
		else
			PlayTetrisMusic(MUSIC_LEVEL00);
	}
	else
		StopTetrisMusic();
}

BOOL CTetris_Game::TestGameOver(int player)
{
	if(TetrisEngine[player].IsGameOver())//game over
	{
		PlayTetrisSound(player, SOUND_GAMEOVER);
		PlayTetrisMusic(MUSIC_LEVEL00);
		m_GameOver_Counter[player] = 0;
		if(playernumber>1)
		{
			if(TetrisEngine[1-player].IsGameOver()&&m_AddFloor[1-player]==EFFECT_NOT_START)
				AddSubtitle(player, Subtitle_Draw, 3*SUBTITLE_TIME2);
			else
			{
				AddSubtitle(1-player, Subtitle_Win, 3*SUBTITLE_TIME2);
				AddSubtitle(player, Subtitle_Lose, 3*SUBTITLE_TIME2);
			}
		}
		else
			AddSubtitle(player, Subtitle_Lose, 3*SUBTITLE_TIME2);
		m_bIsPaused	= FALSE;
		m_bIsPlaying= FALSE;
		return TRUE;
	}
	return FALSE;
}

void CTetris_Game::StopAllSubtitle()
{
	for(int i=0;i<MAX_SUBTITLE;i++)
		Subtitle[i].subcount=0;
}