First version of the SOurce SDK 2013

1 files changed, 293 insertions, 0 deletions

diff --git a/mp/src/game/shared/env_wind_shared.cpp b/mp/src/game/shared/env_wind_shared.cpp
new file mode 100644
index 00000000..9132417b
--- /dev/null
+++ b/mp/src/game/shared/env_wind_shared.cpp
@@ -0,0 +1,293 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+// Information about algorithmic stuff that can occur on both client + server

+//

+// In order to reduce network traffic, it's possible to create a algorithms 

+// that will work on both the client and the server and be totally repeatable. 

+// All we need do is to send down initial conditions and let the algorithm 

+// compute the values at various times. Note that this algorithm will be called 

+// at different times with different frequencies on the client and server.

+//

+// The trick here is that in order for it to be repeatable, the algorithm either

+// cannot depend on random numbers, or, if it does, we need to make sure that 

+// the random numbers generated are effectively done at the beginning of time, 

+// so that differences in frame rate on client and server won't matter. It also 

+// is important that the initial state sent across the network is identical 

+// bitwise so that we produce the exact same results. Therefore no compression 

+// should be used in the datatables. 

+//

+// Note also that each algorithm must have its own random number stream so that

+// it cannot possibly interact with other code using random numbers that will

+// be called at various different intervals on the client + server. Use the

+// CUniformRandomStream class for this.

+//

+// There are two types of client-server neutral code: Code that doesn't interact

+// with player prediction, and code that does. The code that doesn't interact 

+// with player prediction simply has to be able to produce the result f(time) 

+// where time is monotonically increasing. For prediction, we have to produce

+// the result f(time) where time does *not* monotonically increase (time can be 

+// anywhere between the "current" time and the prior 10 seconds).

+//

+// Code that is not used by player prediction can maintain state because later 

+// calls will always compute the value at some future time. This computation can

+// use random number generation, but with the following restriction: Your code 

+// must generate exactly the same number of random numbers regardless of how 

+// frequently the code is called.

+//

+// In specific, this means that all random numbers used must either be computed

+// at init time, or must be used in an 'event-based form'. Namely, use random 

+// numbers to compute the time at which events occur and the random inputs for

+// those events.  When simulating forward, you must simulate all intervening

+// time and generate the same number of random numbers.

+//

+// For functions planned to be used by player prediction, one method is to use

+// some sort of stateless computation (where the only states are the initial

+// state and time). Note that random number generators have state implicit in

+// the number of calls made to that random number generator, and therefore you

+// cannot call a random number generator unless you are able to 

+//

+// 1) Use a random number generator that can return the ith random number, namely:

+//

+//	float r = random( i );	// i == the ith number in the random sequence

+//

+// 2) Be able to accurately know at any given time t how many random numbers 

+//		have already been generated (namely, compute the i in part 1 above).

+//

+// There is another alternative for code meant to be used by player prediction: 

+// you could just store a history of 'events' from which you could completely 

+// determine the value of f(time). That history would need to be at least 10

+// seconds long, which is guaranteed to be longer than the amount of time that

+// prediction would need. I've written a class which I haven't tested yet (but

+// will be using soon) called CTimedEventQueue (currently located in 

+// env_wind_shared.h) which I plan to use to solve my problem (getting wind to

+// blow players).

+//

+//=============================================================================//

+#include "cbase.h"

+#include "env_wind_shared.h"

+#include "soundenvelope.h"

+#include "IEffects.h"

+#include "engine/IEngineSound.h"

+#include "sharedInterface.h"

+

+// memdbgon must be the last include file in a .cpp file!!!

+#include "tier0/memdbgon.h"

+

+//-----------------------------------------------------------------------------

+// globals

+//-----------------------------------------------------------------------------

+static Vector s_vecWindVelocity( 0, 0, 0 );

+

+

+CEnvWindShared::CEnvWindShared() : m_WindAveQueue(10), m_WindVariationQueue(10)

+{

+	m_pWindSound = NULL;

+}

+

+CEnvWindShared::~CEnvWindShared()

+{

+	if (m_pWindSound)

+	{

+		CSoundEnvelopeController::GetController().Shutdown( m_pWindSound );

+	}

+}

+

+void CEnvWindShared::Init( int nEntIndex, int iRandomSeed, float flTime, 

+						  int iInitialWindYaw, float flInitialWindSpeed )

+{

+	m_iEntIndex = nEntIndex;

+	m_flWindAngleVariation = m_flWindSpeedVariation = 1.0f;

+	m_flStartTime = m_flSimTime = m_flSwitchTime = m_flVariationTime = flTime;

+	m_iWindSeed = iRandomSeed;

+	m_Stream.SetSeed( iRandomSeed );

+	m_WindVariationStream.SetSeed( iRandomSeed );

+	m_iWindDir = m_iInitialWindDir = iInitialWindYaw;

+

+	m_flAveWindSpeed = m_flWindSpeed = m_flInitialWindSpeed = flInitialWindSpeed;

+

+	/*

+	// Cache in the wind sound...

+	if (!g_pEffects->IsServer())

+	{

+		CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();

+		m_pWindSound = controller.SoundCreate( -1, CHAN_STATIC, 

+			"EnvWind.Loop", ATTN_NONE );

+		controller.Play( m_pWindSound, 0.0f, 100 );

+	}

+	*/

+

+	// Next time a change happens (which will happen immediately), it'll stop gusting

+	m_bGusting = true;

+}

+

+

+//-----------------------------------------------------------------------------

+// Computes wind variation

+//-----------------------------------------------------------------------------

+

+#define WIND_VARIATION_UPDATE_TIME 0.1f

+

+void CEnvWindShared::ComputeWindVariation( float flTime )

+{

+	// The wind variation is updated every 10th of a second..

+	while( flTime >= m_flVariationTime )

+	{

+		m_flWindAngleVariation = m_WindVariationStream.RandomFloat( -10, 10 );

+		m_flWindSpeedVariation = 1.0 + m_WindVariationStream.RandomFloat( -0.2, 0.2 );

+		m_flVariationTime += WIND_VARIATION_UPDATE_TIME;

+	}

+}

+

+

+

+//-----------------------------------------------------------------------------

+// Updates the wind sound

+//-----------------------------------------------------------------------------

+void CEnvWindShared::UpdateWindSound( float flTotalWindSpeed )

+{

+	if (!g_pEffects->IsServer())

+	{

+		float flDuration = random->RandomFloat( 1.0f, 2.0f );

+		CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();

+

+		// FIXME: Tweak with these numbers

+		float flNormalizedWindSpeed = flTotalWindSpeed / 150.0f;

+		if (flNormalizedWindSpeed > 1.0f)

+			flNormalizedWindSpeed = 1.0f;

+		float flPitch = 120 * Bias( flNormalizedWindSpeed, 0.3f ) + 100;

+		float flVolume = 0.3f * Bias( flNormalizedWindSpeed, 0.3f ) + 0.7f;

+		controller.SoundChangePitch( m_pWindSound, flPitch, flDuration );

+		controller.SoundChangeVolume( m_pWindSound, flVolume, flDuration );

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Updates the wind speed

+//-----------------------------------------------------------------------------

+

+#define WIND_ACCELERATION	150.0f	// wind speed can accelerate this many units per second

+#define WIND_DECELERATION	15.0f	// wind speed can decelerate this many units per second

+

+float CEnvWindShared::WindThink( float flTime )

+{

+	// NOTE: This algorithm can be client-server neutal because we're using 

+	// the random number generator to generate *time* at which the wind changes.

+	// We therefore need to structure the algorithm so that no matter the

+	// frequency of calls to this function we produce the same wind speeds...

+

+	ComputeWindVariation( flTime );

+

+	while (true)

+	{

+		// First, simulate up to the next switch time...

+		float flTimeToSwitch = m_flSwitchTime - m_flSimTime;

+		float flMaxDeltaTime = flTime - m_flSimTime;

+

+		bool bGotToSwitchTime = (flMaxDeltaTime > flTimeToSwitch);

+

+		float flSimDeltaTime = bGotToSwitchTime ? flTimeToSwitch : flMaxDeltaTime;

+

+		// Now that we've chosen 

+		// either ramp up, or sleep till change

+		bool bReachedSteadyState = true;

+		if ( m_flAveWindSpeed > m_flWindSpeed )

+		{

+			m_flWindSpeed += WIND_ACCELERATION * flSimDeltaTime;

+			if (m_flWindSpeed > m_flAveWindSpeed)

+				m_flWindSpeed = m_flAveWindSpeed;

+			else

+				bReachedSteadyState = false;

+		}

+		else if ( m_flAveWindSpeed < m_flWindSpeed )

+		{

+			m_flWindSpeed -= WIND_DECELERATION * flSimDeltaTime;

+			if (m_flWindSpeed < m_flAveWindSpeed)

+				m_flWindSpeed = m_flAveWindSpeed;

+			else

+				bReachedSteadyState = false;

+		}

+

+		// Update the sim time

+

+		// If we didn't get to a switch point, then we're done simulating for now 

+		if (!bGotToSwitchTime)

+		{

+			m_flSimTime = flTime;

+

+			// We're about to exit, let's set the wind velocity...

+			QAngle vecWindAngle( 0, m_iWindDir + m_flWindAngleVariation, 0 );

+			AngleVectors( vecWindAngle, &s_vecWindVelocity );

+			float flTotalWindSpeed = m_flWindSpeed * m_flWindSpeedVariation;

+			s_vecWindVelocity *= flTotalWindSpeed;

+

+			// If we reached a steady state, we don't need to be called until the switch time

+			// Otherwise, we should be called immediately

+

+			// FIXME: If we ever call this from prediction, we'll need

+			// to only update the sound if it's a new time

+			// Or, we'll need to update the sound elsewhere.

+			// Update the sound....

+//			UpdateWindSound( flTotalWindSpeed );

+

+			// Always immediately call, the wind is forever varying

+			return ( flTime + 0.01f );

+		}

+

+		m_flSimTime = m_flSwitchTime;

+

+		// Switch gusting state..

+		if( m_bGusting )

+		{

+			// wind is gusting, so return to normal wind

+			m_flAveWindSpeed = m_Stream.RandomInt( m_iMinWind, m_iMaxWind );

+

+			// set up for another gust later

+			m_bGusting = false;

+			m_flSwitchTime += m_flMinGustDelay + m_Stream.RandomFloat( 0, m_flMaxGustDelay );

+

+#ifndef CLIENT_DLL

+			m_OnGustEnd.FireOutput( NULL, NULL );

+#endif

+		}

+		else

+		{

+			// time for a gust.

+			m_flAveWindSpeed = m_Stream.RandomInt( m_iMinGust, m_iMaxGust );

+

+			// change wind direction, maybe a lot

+			m_iWindDir = anglemod( m_iWindDir + m_Stream.RandomInt(-m_iGustDirChange, m_iGustDirChange) );

+

+			// set up to stop the gust in a short while

+			m_bGusting = true;

+

+#ifndef CLIENT_DLL

+			m_OnGustStart.FireOutput( NULL, NULL );

+#endif

+

+			// !!!HACKHACK - gust duration tied to the length of a particular wave file

+			m_flSwitchTime += m_flGustDuration;

+		}

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Method to reset windspeed..

+//-----------------------------------------------------------------------------

+void ResetWindspeed()

+{

+	s_vecWindVelocity.Init( 0, 0, 0 );

+}

+

+

+//-----------------------------------------------------------------------------

+// Method to sample the windspeed at a particular time

+//-----------------------------------------------------------------------------

+void GetWindspeedAtTime( float flTime, Vector &vecVelocity )

+{

+	// For now, ignore history and time.. fix later when we use wind to affect

+	// client-side prediction

+	VectorCopy( s_vecWindVelocity, vecVelocity );

+}