bloodclientshell.cpp

Blood 2全套源码

	if (m_bModelFBOriginallyEnabled)
	{
		pClientDE->RunConsoleString ("ModelFullbrite 1");
	}

	if (m_bLightmappingOriginallyEnabled)
	{
		pClientDE->RunConsoleString ("LightMap 1");
	}
}


// --------------------------------------------------------------------------- //
//
//	ROUTINE:	CBloodClientShell::OnEnterWorld()
//
//	PURPOSE:	Function called when the client first enters the world.
//
// --------------------------------------------------------------------------- //

void CBloodClientShell::OnEnterWorld()
{
	CClientDE* pClientDE = GetClientDE();
	if (!pClientDE) return;

	m_bInWorld = DTRUE;
	m_bHandledStartup = DFALSE;

	m_bFadeIn = m_bFadeOut = DFALSE;

	if (!m_hCamera)
	{
		ObjectCreateStruct cocStruct;
		INIT_OBJECTCREATESTRUCT(cocStruct);
	
		cocStruct.m_ObjectType = OT_CAMERA;
		VEC_INIT(cocStruct.m_Pos)
		ROT_INIT(cocStruct.m_Rotation)
		cocStruct.m_Flags = 0;

		m_hCamera = pClientDE->CreateObject(&cocStruct);
	}
	pClientDE->GetSurfaceDims(pClientDE->GetScreenSurface(), &m_dwScreenWidth, &m_dwScreenHeight);
	m_fovX = DEG2RAD(m_DefFovX);
	m_fovY = m_fovX * m_fovYScale;
    
	pClientDE->SetCameraFOV(m_hCamera, m_fovX, m_fovY);

	// Initialize various variables
	m_SpinAmount = 0;
	m_bZeroXAngle = DFALSE;
	m_fBobPhase = m_fSwayPhase = 0;
	m_fBobHeight = m_fBobWidth = m_fBobCant = m_fShakeCant = 0;
	m_fViewKick = m_fKickTime = 0;

//	m_fVelY = 0.0f;
	m_fViewY = m_fViewYVel = 0.0f;
	m_fWeaponY = m_fWeaponYVel = 0.0f;

	m_fVelMagnitude		= 0;
	m_fEyeLevel			= 0;
	VEC_INIT(m_vMyLastPos);

	m_bDead				= DFALSE;
	m_bDeadNoHide       = DFALSE;
	m_bWonkyVision		= DFALSE;
	m_bWonkyNoMove      = DFALSE;
	m_fWonkyTime		= 0.0f;

	m_bShakeScreen		= DFALSE;
	m_fShakeTime		= 0.0f;
	m_fShakeStart		= 0.0f;
	VEC_INIT(m_vShakeMagnitude);

	m_bFlashScreen		= DFALSE;
	m_fFlashTime		= 0.0f;
	m_fFlashStart		= 0.0f;
	m_fFlashRampUp		= 0.0f;
	VEC_INIT(m_vFlashColor);

	ROT_INIT(m_Rotation)

	// Sky panning
	m_bPanSky			= DFALSE;
	m_fPanSkyOffsetX	= 1.0f;
	m_fPanSkyOffsetZ	= 1.0f;
	m_fPanSkyScaleX		= 1.0f;
	m_fPanSkyScaleZ		= 1.0f;
	m_fCurSkyXOffset	= 0.0f;
	m_fCurSkyZOffset	= 0.0f;

	// Send initial update message
//	SendPlayerUpdateMessage(DTRUE);

	m_fCameraZoom = 0;
	m_b3rdPerson = DFALSE;
	m_playerCamera.SetFirstPerson();

	m_bFirstUpdate = DTRUE;

	g_pClientDE->SetInputState(DTRUE);
	m_bDrawFragBar = DFALSE;
	g_bLevelChange3rdPersonCam = DFALSE;
	g_bLevelChangeNoUpdate     = DFALSE;

	cdataLast.byFlags = 0;
	// Stuff to initialize/send if this is the first world
	if (m_bFirstWorld)
	{
		m_nCurGun = 0;

		m_bSpectatorMode = DFALSE;
	
		m_bZoomView = DFALSE;
//		m_bStoneView = DFALSE;
//		m_bAuraView = DFALSE;

		if( m_hNightGogglesSound )
		{
			g_pClientDE->KillSound( m_hNightGogglesSound );
			m_hNightGogglesSound = DNULL;
		}

		if( m_hTheEyeLoopingSound )
		{
			g_pClientDE->KillSound( m_hTheEyeLoopingSound );
			m_hTheEyeLoopingSound = DNULL;
		}

		int mode = 0;
		if (pClientDE->GetGameMode(&mode) == DE_OK)
		{
			if (mode == STARTGAME_NORMAL)	// Single player game name irrelevant
				_mbscpy((unsigned char*)m_Config.szName, (const unsigned char*)"");
		}

		m_nLastExitType = -1;

		m_CheatMgr.Reset();
	}

	// Reset the status bar
	m_NewStatusBar.Reset();

	//SCHLEGZ 4/27/98 5:45:03 PM: automatically turn on vis lsit deactivation
	pClientDE->RunConsoleString("serv autodeactivate 1");

	m_Music.TermPlayLists();
	m_Music.InitPlayLists( );
	if ( !m_Music.UsingIMA( ))
		m_Music.PlayCDList( );
	else
		m_Music.PlayMusicLevel( m_eMusicLevel );

	VEC_INIT( m_vLastReverbPos );

}


// --------------------------------------------------------------------------- //
//
//	ROUTINE:	CBloodClientShell::OnExitWorld()
//
//	PURPOSE:	Called when the client leaves the world.  Perform cleanup here.
//
// --------------------------------------------------------------------------- //
void CBloodClientShell::OnExitWorld()
{
	CClientDE* pClientDE = GetClientDE();

	m_sfxMgr.RemoveAll();					// Remove all the sfx

	// Kill the music...
	pClientDE->StopMusic (MUSIC_IMMEDIATE);
	m_Music.TermPlayLists();
	m_eMusicLevel  = CMusic::MUSICLEVEL_SILENCE;

	// Pause sounds (this will only pause currently playing sounds, then they'll get removed)
	pClientDE->PauseSounds();

	m_playerCamera.AttachToObject(DNULL);	// Detatch camera


	if (m_hCamera)
	{
		pClientDE->DeleteObject(m_hCamera);
		m_hCamera = DNULL;
	}

	for (int i=0;i<CLIENTWEAPONSLOTS;i++)
	{
		m_abyWeaponID[i] = WEAP_NONE;
		m_abyLWeaponID[i] = WEAP_NONE;
	}
	if (m_pWeapon) 
	{
		delete m_pWeapon;
		m_pWeapon = DNULL;
	}
	if (m_pLWeapon) 
	{
		delete m_pLWeapon;
		m_pLWeapon = DNULL;
	}

	m_hWeapHandObj = DNULL;
	m_hLWeapHandObj = DNULL;

	if (m_hContainerSound)
	{
		pClientDE->KillSound(m_hContainerSound);
		m_hContainerSound = DNULL;
	}

	m_FragInfo.RemoveAllClients();

	m_bInWorld     = DFALSE;
	m_bRollCredits = DFALSE;

	m_Credits.Term();

	m_bNightGogglesActive = DFALSE;
	if( m_hNightGogglesSound )
	{
		g_pClientDE->KillSound( m_hNightGogglesSound );
		m_hNightGogglesSound = DNULL;
	}

	m_bBinocularsActive = DFALSE;
	m_hSeeingEyeObj = m_hOrbObj = m_hLastOrbObj = DNULL;

	if( m_hTheEyeLoopingSound )
	{
		g_pClientDE->KillSound( m_hTheEyeLoopingSound );
		m_hTheEyeLoopingSound = DNULL;
	}

	if( m_hstrObjectivesText )
	{
		g_pClientDE->FreeString( m_hstrObjectivesText );
		m_hstrObjectivesText = DNULL;
	}
	if( m_hstrObjectivesTitle )
	{
		g_pClientDE->FreeString( m_hstrObjectivesTitle );
		m_hstrObjectivesTitle = DNULL;
	}
}



// --------------------------------------------------------------------------- //
//
//	ROUTINE:	CBloodClientShell::SendPlayerUpdateMessage()
//
//	PURPOSE:	Sends player info to the server
//
// --------------------------------------------------------------------------- //

void CBloodClientShell::SendPlayerUpdateMessage(DBOOL bSendAll)
{
	// Get our client pointer...

	CClientDE* pClientDE = GetClientDE();
	if (!pClientDE) return;


	// Determine if it's time to update if we're in multiplayer...

	if (!bSendAll && IsMultiplayerGame())
	{
		g_fPlayerUpdateTimer -= pClientDE->GetFrameTime();
		if (g_fPlayerUpdateTimer > 0.0f) return;
		g_fPlayerUpdateTimer = PLAYER_MULTI_UPDATE_TIMER;
	}


	// Determine the update flags we want...

	DBYTE byUpdateFlags = 0;

	// HACK - send container code to server that is just below our eye
	DVector vPos;
	pClientDE->GetObjectPos(m_hCamera, &vPos);
	vPos.y -= 15.0f;

	HLOCALOBJ objList[1];
	DDWORD dwNum = pClientDE->GetPointContainers(&vPos, objList, 1);

	if (dwNum > 0)
	{
		D_WORD wCode;
		pClientDE->GetContainerCode(objList[0], &wCode );
		cdata.eContainer = ( ContainerCode )wCode;
	}
	else
		cdata.eContainer = m_eCurContainerCode;

	// HACK - send container code to server that is at our feet
	HOBJECT hPlayerObj;
	DVector vDims;
	hPlayerObj = m_pMoveMgr->GetObject( );
	if( hPlayerObj && !m_bDead )
	{
		pClientDE->GetObjectPos( hPlayerObj, &vPos );
		pClientDE->Physics( )->GetObjectDims( hPlayerObj, &vDims );
		vPos.y -= vDims.y;

		HLOCALOBJ objList[1];
		DDWORD dwNum = pClientDE->GetPointContainers( &vPos, objList, 1 );

		if (dwNum > 0)
		{
			cdata.hContainerAtBottom = objList[0];
		}
		else
			cdata.hContainerAtBottom = DNULL;
	}
	else
		cdata.hContainerAtBottom = DNULL;

	// Set mouse aiming
	if (m_bMouseLook || pClientDE->IsCommandOn(COMMAND_MOUSEAIMTOGGLE))
		cdata.byFlags |= CDATA_MOUSEAIMING;
	else
		cdata.byFlags &= ~CDATA_MOUSEAIMING;


	// Determine what we want to send..
	if (!bSendAll)
	{
		if (cdata.byFlags != cdataLast.byFlags)
			byUpdateFlags |= PLAYERUPDATE_FLAGS;
		
		if (cdata.fPitch != cdataLast.fPitch)
			byUpdateFlags |= PLAYERUPDATE_PITCH;
		
		if (cdata.fYaw != cdataLast.fYaw)
			byUpdateFlags |= PLAYERUPDATE_YAW;
		
		if (!VEC_EQU(cdata.GunMuzzlePos, cdataLast.GunMuzzlePos))
			byUpdateFlags |= PLAYERUPDATE_MUZZLE;
		
		if (!VEC_EQU(cdata.lGunMuzzlePos, cdataLast.lGunMuzzlePos))
			byUpdateFlags |= PLAYERUPDATE_LMUZZLE;
		
		if (cdata.MouseAxis0 != cdataLast.MouseAxis0 || cdata.MouseAxis1 != cdataLast.MouseAxis1)
		{
			byUpdateFlags |= PLAYERUPDATE_MOUSE;
		}
		if (cdata.eContainer != cdataLast.eContainer)
			byUpdateFlags |= PLAYERUPDATE_CONTAINER;
		if (cdata.hContainerAtBottom != cdataLast.hContainerAtBottom)
			byUpdateFlags |= PLAYERUPDATE_CONTAINERATBOTTOM;
	}
	else	// Send all params.
	{
		byUpdateFlags = 0xff;
	}

	// Send the stuff.
	if (byUpdateFlags)
	{
		HMESSAGEWRITE hMsg = pClientDE->StartMessage(CMSG_PLAYERUPDATE);

		pClientDE->WriteToMessageByte(hMsg, byUpdateFlags);				// Tell what we are updating

		if (byUpdateFlags & PLAYERUPDATE_FLAGS)
			pClientDE->WriteToMessageByte(hMsg, cdata.byFlags);			// Flags
		
		if (byUpdateFlags & PLAYERUPDATE_PITCH)
			pClientDE->WriteToMessageFloat(hMsg, cdata.fPitch);			// Rotation
		
		if (byUpdateFlags & PLAYERUPDATE_YAW)
			pClientDE->WriteToMessageFloat(hMsg, cdata.fYaw);
		
		if (byUpdateFlags & PLAYERUPDATE_MUZZLE)
			pClientDE->WriteToMessageCompVector(hMsg, &cdata.GunMuzzlePos); // Muzzle pos
		
		if (byUpdateFlags & PLAYERUPDATE_LMUZZLE)
			pClientDE->WriteToMessageCompVector(hMsg, &cdata.lGunMuzzlePos); // Muzzle pos
		
		if (byUpdateFlags & PLAYERUPDATE_MOUSE)
		{
			DFLOAT fMouse0 = cdata.MouseAxis0 * 512;
			CLIPLOWHIGH(fMouse0, -128, 127);
			fMouse0 += 128;
			DFLOAT fMouse1 = cdata.MouseAxis1 * 512;
			CLIPLOWHIGH(fMouse1, -128, 127);
			fMouse1 += 128;

			pClientDE->WriteToMessageByte(hMsg, (DBYTE)fMouse0);			// Mouse axis
			pClientDE->WriteToMessageByte(hMsg, (DBYTE)fMouse1);
		}

		if (byUpdateFlags & PLAYERUPDATE_CONTAINER)
		{
			DBYTE nContainerCode;

			nContainerCode = (DBYTE) cdata.eContainer;
			if( m_pExternalCamera || m_hSeeingEyeObj || m_hOrbObj )
				nContainerCode |= 0x80;
			pClientDE->WriteToMessageByte(hMsg, nContainerCode );	// Container code
		}

		if (byUpdateFlags & PLAYERUPDATE_CONTAINERATBOTTOM )
		{
			pClientDE->WriteToMessageObject(hMsg, cdata.hContainerAtBottom );
		}

		pClientDE->EndMessage(hMsg);
	}
	// Save current cdata
	memcpy(&cdataLast, &cdata, sizeof(ClientData));

	// Send position packet
	HMESSAGEWRITE hMessage = pClientDE->StartMessage(CMSG_PLAYERPOSITION);

	// Write position info.
	m_pMoveMgr->WritePositionInfo(hMessage);

	pClientDE->EndMessage2(hMessage, 0); // Send unguaranteed.
	
//	m_fLastSentYaw	= m_fYaw;
//	m_fLastSentCamCant = m_fCamCant;
//	m_fPlayerInfoLastSendTime = pClientDE->GetTime();
//	m_nPlayerInfoChangeFlags = 0;

}


// --------------------------------------------------------------------------- //
//
//	ROUTINE:	CBloodClientShell::SendPlayerInitMessage()
//
//	PURPOSE:	Sends a message to the server.
//
// --------------------------------------------------------------------------- //
void CBloodClientShell::SendPlayerInitMessage(DBYTE messageID)
{
	HMESSAGEWRITE hMsg;
	CClientDE* pClientDE = GetClientDE();

	if (messageID != CMSG_SINGLEPLAYER_INIT && messageID != CMSG_MULTIPLAYER_INIT)
		return;

	// Only send this if it's a new game.
	if (messageID == CMSG_SINGLEPLAYER_INIT && m_nLastLoadType != LOADTYPE_NEW_GAME)
		return;

	// Start the message
	hMsg = pClientDE->StartMessage(messageID);

	// Send the appropriate data for this message
	switch(messageID)
	{
		case CMSG_SINGLEPLAYER_INIT:
		case CMSG_MULTIPLAYER_INIT:
			{
				int i;
				HSTRING hstrName = DNULL;

				// Load in a B2C file if it's a multiplayer game
				if (IsMultiplayerGame())
				{
					NetPlayer* pPlayerInfo = NetStart_GetPlayerStruct();
					if (!pPlayerInfo) return;

					hstrName = pClientDE->CreateString(pPlayerInfo->m_sName);

					B2C		b2cFile;
					FILE	*file = 0;
					char	filename[128];

					if (strlen(pPlayerInfo->m_sConfig) <= 0)
					{
						CShell_GetConsoleString("NetConfigFile", pPlayerInfo->m_sConfig, "caleb.b2c");
					}

					sprintf(filename, "players\\%s", pPlayerInfo->m_sConfig);

					if(file = fopen(filename, "rb"))
					{
						fread(&b2cFile, sizeof(B2C), 1, file);
						fclose(file);
					}
					else	// just set default stuff
					{
						CSPrint("Warning - Unable to load .b2c file");

						b2cFile.dwCharacter	= CHARACTER_CALEB;
						b2cFile.dwColor		= 1;
						b2cFile.dwStrength	= 5;