racex.cpp

Visual C++ 游戏开发与设计实例 源代码(所有)

								iStart = 0;
								lLastOption = GetTickCount();
							}
							else
							{
								m_iState = GS_WAITCOMPETITION;
								iStart = 0;
								lLastOption = GetTickCount();
							}
						}
						else
						{
							m_pMultiPlayer.SendTo(0, MSG_PLAYER_READY, NULL, 0, DPNSEND_SYNC | DPNSEND_NOLOOPBACK | DPNSEND_GUARANTEED);
							if(m_iState != GS_RACE)
								m_iState = GS_WAITCOMPETITION;
							iStart = 0;
							lLastOption = GetTickCount();
						}
					}
					else
					{
						m_iState = GS_RACE;
						iStart = 0;
						lLastOption = GetTickCount();
					}
				}
				iStart = 0;
				lLastOption = GetTickCount();
				break;
			}
		}
		break;
	}

}

void cRaceXApp::IncomingMessage(DWORD dwType, int idSender, BYTE* pBuffer, DWORD dwBufferSize)
{
	LPBYTE				pTmpBuffer;
	DWORD				dwTmp;
	BYTE				bTmp;
	string				sTmp;
	char				buffer[1024];
	int					iOffset, i;

	// This is a virtual function of the cMessageHandler class
	// and is used on multiplayer games

	// Here we receive all the messages from the network, and process them
	// based on theier type.

	switch(dwType)
	{
	case MSG_PLAYER_READY:
		if(m_pMultiPlayer.IsHosting())
		{
			m_pCompetition.SetReadyState(m_pCompetition.GetPlayerIDbyDPNID(idSender), TRUE);
		}
		break;
	case MSG_PLAYER_INFO:
		memcpy(&dwTmp, pBuffer, sizeof(DWORD));
		memcpy(buffer, (pBuffer+sizeof(DWORD)), dwBufferSize-sizeof(DWORD));
		buffer[dwBufferSize-sizeof(DWORD)] = '\0';
		m_pCompetition.SetPlayerColor(m_pCompetition.GetPlayerIDbyDPNID(idSender), dwTmp);
		m_pCompetition.SetPlayerName(m_pCompetition.GetPlayerIDbyDPNID(idSender), buffer);
		m_pCompetition.SetReadyState(m_pCompetition.GetPlayerIDbyDPNID(idSender), TRUE);

		iOffset = 0;
		dwTmp = m_pCompetition.GetNumberOfCars();
		memcpy(&buffer[iOffset], &dwTmp , sizeof(DWORD));
		iOffset += sizeof(int);
		for(i=0;i<m_pCompetition.GetNumberOfCars();i++)
		{
			bTmp = m_pCompetition.GetPlayerID(i);
			memcpy(&buffer[iOffset], &bTmp , sizeof(BYTE));
			iOffset += sizeof(BYTE);

			dwTmp = m_pCompetition.GetPlayerDPNID(m_pCompetition.GetPlayerID(i));
			memcpy(&buffer[iOffset], &dwTmp , sizeof(DWORD));
			iOffset += sizeof(DWORD);

			dwTmp = m_pCompetition.GetPlayerColor(m_pCompetition.GetPlayerID(i));
			memcpy(&buffer[iOffset], &dwTmp , sizeof(DWORD));
			iOffset += sizeof(DWORD);

			sTmp = m_pCompetition.GetPlayerName(m_pCompetition.GetPlayerID(i));
			dwTmp = sTmp.size();
			memcpy(&buffer[iOffset], &dwTmp , sizeof(DWORD));
			iOffset += sizeof(DWORD);

			memcpy(&buffer[iOffset], &sTmp[0] , dwTmp);
			iOffset += dwTmp;
		}

		m_pMultiPlayer.SendTo(DPNID_ALL_PLAYERS_GROUP, MSG_RACECARS_INFO, (unsigned char *) &buffer[0], iOffset+1, DPNSEND_SYNC | DPNSEND_NOLOOPBACK | DPNSEND_GUARANTEED);
		break;
	case MSG_RACECARS_INFO:
		if(!m_pMultiPlayer.IsHosting())
		{
			DWORD	dwNumCars;
			BYTE	bPlayerId;
			int		iPlayerDPNID;
			int		iCarColor;

			m_pCompetition.Reset();

			pTmpBuffer = pBuffer;
			memcpy(&dwNumCars, pTmpBuffer, sizeof(DWORD));
			pTmpBuffer+=sizeof(DWORD);
			
			for(i=0;i<dwNumCars;i++)
			{
				memcpy(&bPlayerId, pTmpBuffer, sizeof(BYTE));
				pTmpBuffer+=sizeof(BYTE);
				
				memcpy(&iPlayerDPNID, pTmpBuffer, sizeof(DWORD));
				pTmpBuffer+=sizeof(DWORD);

				memcpy(&iCarColor, pTmpBuffer, sizeof(DWORD));
				pTmpBuffer+=sizeof(DWORD);
				
				memcpy(&dwTmp, pTmpBuffer, sizeof(DWORD));
				pTmpBuffer+=sizeof(DWORD);

				memcpy(&buffer[0], pTmpBuffer ,dwTmp);
				buffer[dwTmp] = '\0';
				pTmpBuffer+=dwTmp;

				sTmp = buffer;
#ifdef _DEBUG
				Log("CAR: PID: %d, DPNID: %d, NAME: %s, MYID: %d\n",bPlayerId, iPlayerDPNID,  &buffer[0], m_pMultiPlayer.GetMyId());
#endif

				m_pCompetition.AddPlayer(sTmp, iCarColor,m_pMultiPlayer.GetMyId()==iPlayerDPNID ? CTRL_NETWORK_LOCAL : CTRL_NETWORK_REMOTE, bPlayerId, iPlayerDPNID); 
			}
		}
		break;
	case MSG_START_RACE:
		if(!m_pMultiPlayer.IsHosting())
		{
			if(m_iState == GS_NETWORKSTATUS)
			{
				for(i=0;i<4;i++)
				{
					m_surfBigCars[i].Destroy();
				}

				m_sptrCar.Destroy();
			}
			memcpy(&buffer[0], pBuffer, dwBufferSize);
			buffer[dwBufferSize] = '\0';
			pRaceTrack.ReadFromFile(buffer);

			m_bSendKeyboard = TRUE;
			m_iState = GS_RACE;
			iStart = 0;				
		}			
		break;
	case MSG_KEYBOARD_STATUS:
		if(m_pMultiPlayer.IsHosting())
		{
			BYTE	bStatus;
			BYTE	bInformation = 0;
			BYTE	buffer[200];
			int		iOffset = 0;
			BYTE	bID, bSpeed, bPosition, bLaps, bMask, bAngle, bState;
			DWORD	dwElapseTime, dwLastLapTime;
			unsigned short iCarX, iCarY;
			int		iX, iY;

			memcpy(&bStatus, pBuffer, sizeof(BYTE));
			pRaceTrack.SetRemoteKeyboardStatus(m_pCompetition.GetPlayerIDbyDPNID(idSender), bStatus);

			for(i=0;i<(int)pRaceTrack.GetNumberOfCars();i++)
			{
				iOffset = 0;
				bID = pRaceTrack.m_pRaceCars[i]->GetID();
				
				memcpy(&buffer[iOffset], &bID, sizeof(BYTE));
				iOffset+=sizeof(BYTE);
				
				if(idSender == m_pCompetition.GetPlayerDPNID(bID))
				{
					bMask = 0;

					dwElapseTime = pRaceTrack.m_pRaceCars[i]->GetLapElapseTime();
					memcpy(&buffer[iOffset], &dwElapseTime, sizeof(DWORD));
					iOffset+=sizeof(DWORD);

					int iMaskOffset = iOffset;
					iOffset++;

					if(pRaceTrack.m_pRaceCars[i]->m_iLaps != pRaceTrack.m_pRaceCars[i]->m_bLastSent_Laps)
					{
						bMask |= 0x01;
						bLaps = pRaceTrack.m_pRaceCars[i]->m_iLaps;
						memcpy(&buffer[iOffset], &bLaps, sizeof(BYTE));
						iOffset+=sizeof(BYTE);
						pRaceTrack.m_pRaceCars[i]->m_bLastSent_Laps = pRaceTrack.m_pRaceCars[i]->m_iLaps;
					}

					if((pRaceTrack.m_pRaceCars[i]->GetSpeed()/10) != pRaceTrack.m_pRaceCars[i]->m_bLastSent_Speed)
					{
						bMask |= 0x02;
						bSpeed = (pRaceTrack.m_pRaceCars[i]->GetSpeed() / 10);
						memcpy(&buffer[iOffset], &bSpeed, sizeof(BYTE));
						iOffset+=sizeof(BYTE);
						pRaceTrack.m_pRaceCars[i]->m_bLastSent_Speed = (pRaceTrack.m_pRaceCars[i]->GetSpeed()/10);
					}

					if(pRaceTrack.m_pRaceCars[i]->GetPosition() != pRaceTrack.m_pRaceCars[i]->m_bLastSent_Position)
					{
						bMask |= 0x04;
						bPosition = pRaceTrack.m_pRaceCars[i]->GetPosition();
						memcpy(&buffer[iOffset], &bPosition, sizeof(BYTE));
						iOffset+=sizeof(BYTE);
						pRaceTrack.m_pRaceCars[i]->m_bLastSent_Position = pRaceTrack.m_pRaceCars[i]->GetPosition();
					}

					if(pRaceTrack.m_pRaceCars[i]->GetLastLapTime() != pRaceTrack.m_pRaceCars[i]->m_dwLastSent_LastLapTime)
					{
						bMask |= 0x08;
						dwLastLapTime = pRaceTrack.m_pRaceCars[i]->GetLastLapTime();
						memcpy(&buffer[iOffset], &dwLastLapTime, sizeof(DWORD));
						iOffset+=sizeof(DWORD);						
						pRaceTrack.m_pRaceCars[i]->m_dwLastSent_LastLapTime = pRaceTrack.m_pRaceCars[i]->GetLastLapTime();
					}

					pRaceTrack.m_pRaceCars[i]->GetPos(&iX, &iY);
					iCarX = (unsigned short) iX;
					iCarY = (unsigned short) iY;

					if(iCarX != pRaceTrack.m_pRaceCars[i]->m_nLastSent_PosX)
					{
						bMask |= 0x10;
						memcpy(&buffer[iOffset], &iCarX, sizeof(unsigned short));
						iOffset+=sizeof(unsigned short);						
						pRaceTrack.m_pRaceCars[i]->m_nLastSent_PosX = iCarX;
					}

					if(iCarY != pRaceTrack.m_pRaceCars[i]->m_nLastSent_PosY)
					{
						bMask |= 0x20;
						memcpy(&buffer[iOffset], &iCarY, sizeof(unsigned short));
						iOffset+=sizeof(unsigned short);						
						pRaceTrack.m_pRaceCars[i]->m_nLastSent_PosY = iCarY;
					}

					if(pRaceTrack.m_pRaceCars[i]->m_iAngle != pRaceTrack.m_pRaceCars[i]->m_bLastSent_Angle)
					{
						bMask |= 0x40;
						bAngle = (BYTE) (pRaceTrack.m_pRaceCars[i]->m_iAngle / 10);
						memcpy(&buffer[iOffset], &bAngle, sizeof(BYTE));
						iOffset+=sizeof(BYTE);
						pRaceTrack.m_pRaceCars[i]->m_bLastSent_Angle = (BYTE) pRaceTrack.m_pRaceCars[i]->m_iAngle;
					}

					if(pRaceTrack.m_pRaceCars[i]->GetCarState() != pRaceTrack.m_pRaceCars[i]->m_bLastSent_CarState)
					{
						bMask |= 0x80;
						bState = (BYTE) pRaceTrack.m_pRaceCars[i]->GetCarState();
						memcpy(&buffer[iOffset], &bState, sizeof(BYTE));
						iOffset+=sizeof(BYTE);
						pRaceTrack.m_pRaceCars[i]->m_bLastSent_CarState = pRaceTrack.m_pRaceCars[i]->GetCarState();
					}

					memcpy(&buffer[iMaskOffset], &bMask, sizeof(BYTE));

					m_pMultiPlayer.SendTo(idSender, MSG_RACECARS_STATUS, (unsigned char *) &buffer[0], iOffset, 0 /*DPNSEND_SYNC*/);
				}
				else
				{
					pRaceTrack.m_pRaceCars[i]->GetPos(&iX, &iY);
					iCarX = (unsigned short) iX;
					iCarY = (unsigned short) iY;

					memcpy(&buffer[iOffset], &iCarX, sizeof(unsigned short));
					iOffset+=sizeof(unsigned short);						

					memcpy(&buffer[iOffset], &iCarY, sizeof(unsigned short));
					iOffset+=sizeof(unsigned short);						

					bState = (BYTE) pRaceTrack.m_pRaceCars[i]->GetCarState();
					memcpy(&buffer[iOffset], &bState, sizeof(BYTE));
					iOffset+=sizeof(BYTE);

					if(bState == CARSTATE_RACECOMPLETED)
					{
						bPosition = (BYTE) (pRaceTrack.m_pRaceCars[i]->GetPosition());
						memcpy(&buffer[iOffset], &bPosition, sizeof(BYTE));
						iOffset+=sizeof(BYTE);
					}
					else
					{
						bAngle = (BYTE) (pRaceTrack.m_pRaceCars[i]->m_iAngle / 10);
						memcpy(&buffer[iOffset], &bAngle, sizeof(BYTE));
						iOffset+=sizeof(BYTE);
					}

					m_pMultiPlayer.SendTo(idSender, MSG_RACECARS_STATUS, (unsigned char *) &buffer[0], iOffset, 0 /*DPNSEND_SYNC*/);
				} /* IF SENDER*/
			} /* FOR */
		} /* IF IS HOSTING */
		break;
	case MSG_COMPETITIONSTATUS:
		m_pCompetition.SetCompetitionMode(TRUE);
		m_iState = GS_COMPETITIONSTATUS;
		iStart = 0;
		m_sndSelect.Play();
		break;
	case MSG_RACECARS_STATUS:
		if(!m_pMultiPlayer.IsHosting())
		{
			BYTE	bCarId;
			unsigned short iCarX = -1, iCarY = -1;
			BYTE	bCarPosition = -1;
			BYTE	bCarState = -1;
			BYTE	bAngle = -1;
			BYTE	bSpeed = -1;
			BYTE	bPosition = -1;
			BYTE	bLaps = -1;
			BYTE	bMask = -1;
			DWORD	dwLastLapTime = -1;
			DWORD	dwElapseTime = -1;

			pTmpBuffer = pBuffer;
			memcpy(&bCarId, pTmpBuffer, sizeof(BYTE));
			pTmpBuffer+=sizeof(BYTE);
						
			if(bCarId == pRaceTrack.GetLocalCarID())
			{
				memcpy(&dwElapseTime, pTmpBuffer, sizeof(DWORD));
				pTmpBuffer+=sizeof(DWORD);
				
				memcpy(&bMask, pTmpBuffer, sizeof(BYTE));
				pTmpBuffer+=sizeof(BYTE);

				if(bMask & 0x01)
				{
					memcpy(&bLaps, pTmpBuffer, sizeof(BYTE));
					pTmpBuffer+=sizeof(BYTE);
				}

				if(bMask & 0x02)
				{
					memcpy(&bSpeed, pTmpBuffer, sizeof(BYTE));
					pTmpBuffer+=sizeof(BYTE);
				}

				if(bMask & 0x04)
				{
					memcpy(&bPosition, pTmpBuffer, sizeof(BYTE));
					pTmpBuffer+=sizeof(BYTE);
				}

				if(bMask & 0x08)
				{
					memcpy(&dwLastLapTime, pTmpBuffer, sizeof(DWORD));
					pTmpBuffer+=sizeof(DWORD);
				}

				if(bMask & 0x10)
				{
					memcpy(&iCarX, pTmpBuffer, sizeof(unsigned short));
					pTmpBuffer+=sizeof(unsigned short);			
				}

				if(bMask & 0x20)
				{
					memcpy(&iCarY, pTmpBuffer, sizeof(unsigned short));
					pTmpBuffer+=sizeof(unsigned short);			
				}

				if(bMask & 0x40)
				{
					memcpy(&bAngle, pTmpBuffer, sizeof(BYTE));
					pTmpBuffer+=sizeof(BYTE);

				}

				if(bMask & 0x80)
				{
					memcpy(&bCarState, pTmpBuffer, sizeof(BYTE));
					pTmpBuffer+=sizeof(BYTE);
				}

				m_bSendKeyboard = TRUE;
			}
			else
			{
				bMask = 0;
				bMask |= 0x10;
				bMask |= 0x20;
				bMask |= 0x80;

				memcpy(&iCarX, pTmpBuffer, sizeof(unsigned short));
				pTmpBuffer+=sizeof(unsigned short);			
				memcpy(&iCarY, pTmpBuffer, sizeof(unsigned short));
				pTmpBuffer+=sizeof(unsigned short);			
				memcpy(&bCarState, pTmpBuffer, sizeof(BYTE));
				pTmpBuffer+=sizeof(BYTE);
				if(bCarState == CARSTATE_RACECOMPLETED)
				{
					bMask |= 0x04;
					memcpy(&bPosition, pTmpBuffer, sizeof(BYTE));
					pTmpBuffer+=sizeof(BYTE);
				}
				else
				{
					bMask |= 0x40;
					memcpy(&bAngle, pTmpBuffer, sizeof(BYTE));
					pTmpBuffer+=sizeof(BYTE);
				}
			}

			pRaceTrack.SetCarInfo(bCarId, bMask, dwElapseTime,
				bLaps,
				bSpeed,
				bPosition,
				dwLastLapTime,
				iCarX,
				iCarY,
				bAngle,
				bCarState);
		}
		break;
	}

	return;
}


void cRaceXApp::AppInitialized()
{
	// Hide the mouse cursor
	ShowCursor(FALSE);

	m_pSoundInterface.Initialize(GetMainWnd(), DSSCL_PRIORITY );

	if(m_Keyboard.Create() == FALSE)
	{
		DXTRACE_MSG("Failed To Initialize Keyboard Input");
		PostQuitMessage(0);
	}

	if(m_Mouse.Create() == FALSE)
	{
		DXTRACE_MSG("Failed To Initialize Keyboard Input");
		PostQuitMessage(0);
	}

	if(m_pMultiPlayer.Initialize() == FALSE)
	{
		DXTRACE_MSG("Failed To Initialize Multiplayer Support.");
		PostQuitMessage(0);
	}
	else
	{
		m_pMultiPlayer.SetHandler(this);
		m_pMultiPlayer.EnumServiceProviders();
	}

	m_iDifficultyLevel =