自学教程：C++ ASSERTSZ函数代码示例

/*=============AngularMovecalculate pev->velocity and pev->nextthink to reach vecDest frompev->origin traveling at flSpeedJust like LinearMove, but rotational.===============*/void CBaseToggle :: AngularMove( Vector vecDestAngle, float flSpeed ){	ASSERTSZ(flSpeed != 0, "AngularMove:  no speed is defined!");//	ASSERTSZ(m_pfnCallWhenMoveDone != NULL, "AngularMove: no post-move function defined");		m_vecFinalAngle = vecDestAngle;	// Already there?	if (vecDestAngle == pev->angles)	{		AngularMoveDone();		return;	}		// set destdelta to the vector needed to move	Vector vecDestDelta = vecDestAngle - pev->angles;		// divide by speed to get time to reach dest	float flTravelTime = vecDestDelta.Length() / flSpeed;	if( flTravelTime < 0.1f )	{		pev->avelocity = g_vecZero;		pev->nextthink = pev->ltime + 0.1f;		return;	}	// set nextthink to trigger a call to AngularMoveDone when dest is reached	pev->nextthink = pev->ltime + flTravelTime;	SetThink( &CBaseToggle::AngularMoveDone );	// scale the destdelta vector by the time spent traveling to get velocity	pev->avelocity = vecDestDelta / flTravelTime;}

//-----------------------------------------------------------------------------// Purpose: Calculate m_vecVelocity and m_flNextThink to reach vecDest from//			GetLocalOrigin() traveling at flSpeed. Just like LinearMove, but rotational.// Input  : vecDestAngle - //			flSpeed - //-----------------------------------------------------------------------------void CBaseToggle::AngularMove( const QAngle &vecDestAngle, float flSpeed ){	ASSERTSZ(flSpeed != 0, "AngularMove:  no speed is defined!");		m_vecFinalAngle = vecDestAngle;	m_movementType = MOVE_TOGGLE_ANGULAR;	// Already there?	if (vecDestAngle == GetLocalAngles())	{		MoveDone();		return;	}		// set destdelta to the vector needed to move	QAngle vecDestDelta = vecDestAngle - GetLocalAngles();		// divide by speed to get time to reach dest	float flTravelTime = vecDestDelta.Length() / flSpeed;	const float MinTravelTime = 0.01f;	if ( flTravelTime < MinTravelTime )	{		// If we only travel for a short time, we can fail WillSimulateGamePhysics()		flTravelTime = MinTravelTime;		flSpeed = vecDestDelta.Length() / flTravelTime;	}	// set m_flNextThink to trigger a call to AngularMoveDone when dest is reached	SetMoveDoneTime( flTravelTime );	// scale the destdelta vector by the time spent traveling to get velocity	SetLocalAngularVelocity( vecDestDelta * (1.0 / flTravelTime) );}

//LRCvoid CBaseDoor :: PostSpawn( void ){	if (m_pMoveWith)		m_vecPosition1 = pev->origin - m_pMoveWith->pev->origin;	else		m_vecPosition1 = pev->origin;	// Subtract 2 from size because the engine expands bboxes by 1 in all directions	m_vecPosition2	= m_vecPosition1 + (pev->movedir * (fabs( pev->movedir.x * (pev->size.x-2) ) + fabs( pev->movedir.y * (pev->size.y-2) ) + fabs( pev->movedir.z * (pev->size.z-2) ) - m_flLip));	ASSERTSZ(m_vecPosition1 != m_vecPosition2, "door start/end positions are equal");	if ( FBitSet (pev->spawnflags, SF_DOOR_START_OPEN) )	{	// swap pos1 and pos2, put door at pos2		if (m_pMoveWith)		{			m_vecSpawnOffset = m_vecSpawnOffset + (m_vecPosition2 + m_pMoveWith->pev->origin) - pev->origin;			UTIL_AssignOrigin(this, m_vecPosition2 + m_pMoveWith->pev->origin);		}		else		{			m_vecSpawnOffset = m_vecSpawnOffset + m_vecPosition2 - pev->origin;			UTIL_AssignOrigin(this, m_vecPosition2);		}		Vector vecTemp = m_vecPosition2;		m_vecPosition2 = m_vecPosition1;		m_vecPosition1 = vecTemp;//		ALERT(at_console, "func_door postspawn: origin %f %f %f/n", pev->origin.x, pev->origin.y, pev->origin.z);	}}

void CMomentaryDoor::Spawn( void ){	SetMovedir (pev);	pev->solid		= SOLID_BSP;	pev->movetype	= MOVETYPE_PUSH;	UTIL_SetOrigin(pev, pev->origin);	SET_MODEL( ENT(pev), STRING(pev->model) );		if (pev->speed == 0)		pev->speed = 100;	if (pev->dmg == 0)		pev->dmg = 2;		m_vecPosition1	= pev->origin;	// Subtract 2 from size because the engine expands bboxes by 1 in all directions making the size too big	m_vecPosition2	= m_vecPosition1 + (pev->movedir * (fabs( pev->movedir.x * (pev->size.x-2) ) + fabs( pev->movedir.y * (pev->size.y-2) ) + fabs( pev->movedir.z * (pev->size.z-2) ) - m_flLip));	ASSERTSZ(m_vecPosition1 != m_vecPosition2, "door start/end positions are equal");	if ( FBitSet (pev->spawnflags, SF_DOOR_START_OPEN) )	{	// swap pos1 and pos2, put door at pos2		UTIL_SetOrigin(pev, m_vecPosition2);		m_vecPosition2 = m_vecPosition1;		m_vecPosition1 = pev->origin;	}	SetTouch( NULL );		Precache();}

//-----------------------------------------------------------------------------// Purpose: Called when spawning, after keyvalues have been handled.//-----------------------------------------------------------------------------void CASW_Jump_Trigger::Spawn( void ){	BaseClass::Spawn();	InitTrigger();	if ( m_flWait == 0 )	{		m_flWait = 0.2;	}	ASSERTSZ( m_iHealth == 0, "trigger_asw_jump with health" );			// find the target this use area is attached to	m_iNumJumpDests = 0;	CBaseEntity *pEnt = gEntList.FindEntityByName( NULL, m_JumpDestName, NULL );	while ( pEnt )	{		m_vecJumpDestination[m_iNumJumpDests] = pEnt->GetAbsOrigin();		m_iNumJumpDests++;		pEnt = gEntList.FindEntityByName(pEnt, m_JumpDestName, NULL);	}	if ( m_iNumJumpDests > 0 || m_bForceJump )	{		SetTouch( &CASW_Jump_Trigger::VolumeTouch );	}	else	{		Msg("Error: trigger_asw_jump has no valid destinations./n");	}	//Assert(!m_hUseTarget);}

/*=============LinearMovecalculate pev->velocity and pev->nextthink to reach vecDest frompev->origin traveling at flSpeed===============*/void CBaseToggle ::  LinearMove( Vector	vecDest, float flSpeed ){	ASSERTSZ(flSpeed != 0, "LinearMove:  no speed is defined!");//	ASSERTSZ(m_pfnCallWhenMoveDone != NULL, "LinearMove: no post-move function defined");		m_vecFinalDest = vecDest;	// Already there?	if (vecDest == pev->origin)	{		LinearMoveDone();		return;	}			// set destdelta to the vector needed to move	Vector vecDestDelta = vecDest - pev->origin;		// divide vector length by speed to get time to reach dest	float flTravelTime = vecDestDelta.Length() / flSpeed;	// set nextthink to trigger a call to LinearMoveDone when dest is reached	pev->nextthink = pev->ltime + flTravelTime;	SetThink( &CBaseToggle::LinearMoveDone );	// scale the destdelta vector by the time spent traveling to get velocity	pev->velocity = vecDestDelta / flTravelTime;}

void CRotButton::Spawn( void ){	Precache();	// set the axis of rotation	AxisDir( pev );	// check for clockwise rotation	if( FBitSet( pev->spawnflags, SF_ROTBUTTON_ROTATE_BACKWARDS ))		pev->movedir = pev->movedir * -1;	pev->movetype = MOVETYPE_PUSH;		if( FBitSet( pev->spawnflags, SF_ROTBUTTON_PASSABLE ))		pev->solid = SOLID_NOT;	else pev->solid = SOLID_BSP;	// shared code use this flag as BUTTON_DONTMOVE so we need to clear it here	ClearBits( pev->spawnflags, SF_ROTBUTTON_PASSABLE );	ClearBits( pev->spawnflags, SF_BUTTON_SPARK_IF_OFF );	ClearBits( pev->spawnflags, SF_BUTTON_DAMAGED_AT_LASER );	SET_MODEL( edict(), GetModel() );		if( pev->speed == 0 )		pev->speed = 40;	if( m_flWait == 0 )		m_flWait = 1;	if( pev->health > 0 )	{		pev->takedamage = DAMAGE_YES;	}	m_iState = STATE_OFF;	m_vecAngle1 = GetLocalAngles();	m_vecAngle2 = GetLocalAngles() + pev->movedir * m_flMoveDistance;	ASSERTSZ( m_vecAngle1 != m_vecAngle2, "rotating button start/end positions are equal" );	m_fStayPushed = (m_flWait == -1) ? TRUE : FALSE;	m_fRotating = TRUE;	// if the button is flagged for USE button activation only, take away it's touch function and add a use function	if( !FBitSet( pev->spawnflags, SF_BUTTON_TOUCH_ONLY ))	{		SetTouch( NULL );		SetUse( &CBaseButton::ButtonUse );	}	else	{			// touchable button		SetTouch( &CBaseButton::ButtonTouch );	}	UTIL_SetOrigin( this, GetLocalOrigin( ));	m_pUserData = WorldPhysic->CreateKinematicBodyFromEntity( this );}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CRotDoor::Spawn( void ){	BaseClass::Spawn();	// set the axis of rotation	CBaseToggle::AxisDir();	// check for clockwise rotation	if ( HasSpawnFlags(SF_DOOR_ROTATE_BACKWARDS) )		m_vecMoveAng = m_vecMoveAng * -1;		//m_flWait			= 2; who the hell did this? (sjb)	m_vecAngle1	= GetLocalAngles();	m_vecAngle2	= GetLocalAngles() + m_vecMoveAng * m_flMoveDistance;	ASSERTSZ(m_vecAngle1 != m_vecAngle2, "rotating door start/end positions are equal/n");	// Starting open allows a func_door to be lighted in the closed position but	// spawn in the open position	//	// SF_DOOR_START_OPEN_OBSOLETE is an old broken way of spawning open that has	// been deprecated.	if ( HasSpawnFlags(SF_DOOR_START_OPEN_OBSOLETE) )	{			// swap pos1 and pos2, put door at pos2, invert movement direction		QAngle vecNewAngles = m_vecAngle2;		m_vecAngle2 = m_vecAngle1;		m_vecAngle1 = vecNewAngles;		m_vecMoveAng = -m_vecMoveAng;		// We've already had our physics setup in BaseClass::Spawn, so teleport to our		// current position. If we don't do this, our vphysics shadow will not update.		Teleport( NULL, &m_vecAngle1, NULL );		m_toggle_state = TS_AT_BOTTOM;	}	else if ( m_eSpawnPosition == FUNC_DOOR_SPAWN_OPEN )	{			// We've already had our physics setup in BaseClass::Spawn, so teleport to our		// current position. If we don't do this, our vphysics shadow will not update.		Teleport( NULL, &m_vecAngle2, NULL );		m_toggle_state = TS_AT_TOP;	}	else	{		m_toggle_state = TS_AT_BOTTOM;	}#ifdef HL1_DLL	SetSolid( SOLID_VPHYSICS );#endif			// Slam the object back to solid - if we really want it to be solid.	if ( m_bSolidBsp )	{		SetSolid( SOLID_BSP );	}}

void CRotButton::Spawn( void ){	char *pszSound;	//----------------------------------------------------	//determine sounds for buttons	//a sound of 0 should not make a sound	//----------------------------------------------------	pszSound = ButtonSound( m_sounds );	PRECACHE_SOUND(pszSound);	pev->noise = ALLOC_STRING(pszSound);	// set the axis of rotation	CBaseToggle::AxisDir( pev );	// check for clockwise rotation	if ( FBitSet (pev->spawnflags, SF_DOOR_ROTATE_BACKWARDS) )		pev->movedir = pev->movedir * -1;	pev->movetype	= MOVETYPE_PUSH;		if ( pev->spawnflags & SF_ROTBUTTON_NOTSOLID )		pev->solid		= SOLID_NOT;	else		pev->solid		= SOLID_BSP;	SET_MODEL(ENT(pev), STRING(pev->model));		if (pev->speed == 0)		pev->speed = 40;	if (m_flWait == 0)		m_flWait = 1;	if (pev->health > 0)	{		pev->takedamage = DAMAGE_YES;	}	m_toggle_state = TS_AT_BOTTOM;	m_vecAngle1	= pev->angles;	m_vecAngle2	= pev->angles + pev->movedir * m_flMoveDistance;	ASSERTSZ(m_vecAngle1 != m_vecAngle2, "rotating button start/end positions are equal");	m_fStayPushed = (m_flWait == -1 ? TRUE : FALSE);	m_fRotating = TRUE;	// if the button is flagged for USE button activation only, take away it's touch function and add a use function	if ( !FBitSet ( pev->spawnflags, SF_BUTTON_TOUCH_ONLY ) )	{		SetTouch ( NULL );		SetUse	 ( &CBaseButton::ButtonUse );	}	else // touchable button		SetTouch( &CBaseButton::ButtonTouch );	//SetTouch( ButtonTouch );}

void CBaseDoor::Spawn( ){	Precache();	SetMovedir (pev);	if ( pev->skin == 0 )	{//normal door		if ( FBitSet (pev->spawnflags, SF_DOOR_PASSABLE) )			pev->solid		= SOLID_NOT;		else			pev->solid		= SOLID_BSP;	}	else	{// special contents		pev->solid		= SOLID_NOT;		SetBits( pev->spawnflags, SF_DOOR_SILENT );	// water is silent for now	}	pev->movetype	= MOVETYPE_PUSH;	UTIL_SetOrigin(pev, pev->origin);	SET_MODEL( ENT(pev), STRING(pev->model) );	// added by jason	if( !stricmp( STRING( pev->classname ), "func_water" ) )	{		pev->skin = CONTENTS_WATER;		pev->rendermode = kRenderTransAlpha;	}		if (pev->speed == 0)		pev->speed = 100;		m_vecPosition1	= pev->origin;	// Subtract 2 from size because the engine expands bboxes by 1 in all directions making the size too big	m_vecPosition2	= m_vecPosition1 + (pev->movedir * (fabs( pev->movedir.x * (pev->size.x-2) ) + fabs( pev->movedir.y * (pev->size.y-2) ) + fabs( pev->movedir.z * (pev->size.z-2) ) - m_flLip));	ASSERTSZ(m_vecPosition1 != m_vecPosition2, "door start/end positions are equal");	if ( FBitSet (pev->spawnflags, SF_DOOR_START_OPEN) )	{	// swap pos1 and pos2, put door at pos2		UTIL_SetOrigin(pev, m_vecPosition2);		m_vecPosition2 = m_vecPosition1;		m_vecPosition1 = pev->origin;	}	m_toggle_state = TS_AT_BOTTOM;		// if the door is flagged for USE button activation only, use NULL touch function	if ( FBitSet ( pev->spawnflags, SF_DOOR_USE_ONLY ) )	{		SetTouch ( NULL );	}	else // touchable button		SetTouch( DoorTouch );}

void CRotDoor::Spawn( void ){	Precache();	// set the axis of rotation	CBaseToggle::AxisDir( pev );	// check for clockwise rotation	if ( FBitSet (pev->spawnflags, SF_DOOR_ROTATE_BACKWARDS) )		pev->movedir = pev->movedir * -1;		//m_flWait			= 2; who the hell did this? (sjb)	m_vecAngle1	= pev->angles;	m_vecAngle2	= pev->angles + pev->movedir * m_flMoveDistance;	ASSERTSZ(m_vecAngle1 != m_vecAngle2, "rotating door start/end positions are equal");		if ( FBitSet (pev->spawnflags, SF_DOOR_PASSABLE) )		pev->solid		= SOLID_NOT;	else		pev->solid		= SOLID_BSP;	pev->movetype	= MOVETYPE_PUSH;	UTIL_SetOrigin(pev, pev->origin);	SET_MODEL(ENT(pev), STRING(pev->model) );	if (pev->speed == 0)		pev->speed = 100;	// DOOR_START_OPEN is to allow an entity to be lighted in the closed position// but spawn in the open position	if ( FBitSet (pev->spawnflags, SF_DOOR_START_OPEN) )	{	// swap pos1 and pos2, put door at pos2, invert movement direction		pev->angles = m_vecAngle2;		Vector vecSav = m_vecAngle1;		m_vecAngle2 = m_vecAngle1;		m_vecAngle1 = vecSav;		pev->movedir = pev->movedir * -1;	}	m_toggle_state = TS_AT_BOTTOM;/*	if ( FBitSet ( pev->spawnflags, SF_DOOR_USE_ONLY ) )	{		SetTouch ( NULL );	}	else // touchable button*/	//sys test		SetTouch( DoorTouch );}

void CBaseDoor::Spawn(){	Precache();	SetMovedir( this );	if( GetSkin() == 0 )	{//normal door		if( GetSpawnFlags().Any( SF_DOOR_PASSABLE ) )			SetSolidType( SOLID_NOT );		else			SetSolidType( SOLID_BSP );	}	else	{// special contents		SetSolidType( SOLID_NOT );		GetSpawnFlags().AddFlags( SF_DOOR_SILENT );	// water is silent for now	}	SetMoveType( MOVETYPE_PUSH );	SetAbsOrigin( GetAbsOrigin() );	SetModel( GetModelName() );	if( GetSpeed() == 0 )		SetSpeed( 100 );	m_vecPosition1 = GetAbsOrigin();	// Subtract 2 from size because the engine expands bboxes by 1 in all directions making the size too big	m_vecPosition2 = m_vecPosition1 + ( GetMoveDir() * ( fabs( GetMoveDir().x * ( GetBounds().x - 2 ) ) + fabs( GetMoveDir().y * ( GetBounds().y - 2 ) ) + fabs( GetMoveDir().z * ( GetBounds().z - 2 ) ) - m_flLip ) );	ASSERTSZ( m_vecPosition1 != m_vecPosition2, "door start/end positions are equal" );	if( GetSpawnFlags().Any( SF_DOOR_START_OPEN ) )	{	// swap pos1 and pos2, put door at pos2		SetAbsOrigin( m_vecPosition2 );		m_vecPosition2 = m_vecPosition1;		m_vecPosition1 = GetAbsOrigin();	}	m_toggle_state = TS_AT_BOTTOM;	// if the door is flagged for USE button activation only, use NULL touch function	if( GetSpawnFlags().Any( SF_DOOR_USE_ONLY ) )	{		SetTouch( NULL );	}	else // touchable button		SetTouch( &CBaseDoor::DoorTouch );}

void CMomentaryDoor::Spawn( void ){	SetMovedir (pev);	pev->solid		= SOLID_BSP;	pev->movetype	= MOVETYPE_PUSH;	UTIL_SetOrigin(this, pev->origin);	SET_MODEL( ENT(pev), STRING(pev->model) );	//	if (pev->speed == 0)//		pev->speed = 100;	if (pev->dmg == 0)		pev->dmg = 2;	m_iState = STATE_OFF;		m_vecPosition1	= pev->origin;	// Subtract 2 from size because the engine expands bboxes by 1 in all directions making the size too big	m_vecPosition2	= m_vecPosition1 + (pev->movedir * (fabs( pev->movedir.x * (pev->size.x-2) ) + fabs( pev->movedir.y * (pev->size.y-2) ) + fabs( pev->movedir.z * (pev->size.z-2) ) - m_flLip));	ASSERTSZ(m_vecPosition1 != m_vecPosition2, "door start/end positions are equal");	//LRC: FIXME, move to PostSpawn	if ( FBitSet (pev->spawnflags, SF_DOOR_START_OPEN) )	{	// swap pos1 and pos2, put door at pos2		UTIL_AssignOrigin(this, m_vecPosition2);		Vector vecTemp = m_vecPosition2;		m_vecPosition2 = m_vecPosition1;		m_vecPosition1 = vecTemp;	}	if (m_pMoveWith)	{		m_vecPosition1 = m_vecPosition1 - m_pMoveWith->pev->origin;		m_vecPosition2 = m_vecPosition2 - m_pMoveWith->pev->origin;	}	Precache();	SetTouch( NULL );	}

/*=============AngularMovecalculate pev->velocity and pev->nextthink to reach vecDest frompev->origin traveling at flSpeedJust like LinearMove, but rotational.===============*/void CBaseToggle :: AngularMove( Vector vecDestAngle, float flSpeed ){	ASSERTSZ(flSpeed != 0, "AngularMove:  no speed is defined!");//	ASSERTSZ(m_pfnCallWhenMoveDone != NULL, "AngularMove: no post-move function defined");		m_vecFinalAngle = vecDestAngle;	m_flAngularMoveSpeed = flSpeed;//	if ((m_pMoveWith || m_pChildMoveWith))// && !bNow)//	{//		ALERT(at_console,"Setting AngularMoveNow to happen after %f/n",gpGlobals->time);	SetThink(&CBaseToggle :: AngularMoveNow );	UTIL_DesiredThink( this );//	ExternalThink( 0.01 );//		pev->nextthink = pev->ltime + 0.01;//	}//	else//	{//		AngularMoveNow(); // starring Martin Sheen and Marlon Brando//	}}

void CBaseToggle ::  LinearMove( Vector	vecInput, float flSpeed, float flAccel, float flDecel )//, BOOL bNow )  // AJH Call this to use acceleration{//	ALERT(at_console, "LMove %s: %f %f %f, speed %f, accel %f /n", STRING(pev->targetname), vecInput.x, vecInput.y, vecInput.z, flSpeed, flAccel);	ASSERTSZ(flSpeed != 0, "LinearMove:  no speed is defined!");//	ASSERTSZ(m_pfnCallWhenMoveDone != NULL, "LinearMove: no post-move function defined");	m_flLinearMoveSpeed = flSpeed;	m_flLinearAccel = flAccel;	m_flLinearDecel = flDecel;	m_flCurrentTime = 0;		if(m_flLinearAccel>0){		m_flAccelTime = m_flLinearMoveSpeed/m_flLinearAccel;	}else{		m_flLinearAccel=-1;		m_flAccelTime=0;	}	if(m_flLinearDecel>0){	m_flDecelTime = m_flLinearMoveSpeed/m_flLinearDecel;	}else{		m_flLinearDecel=-1;		m_flDecelTime=0;	}	m_vecFinalDest = vecInput;//	if ((m_pMoveWith || m_pChildMoveWith))// && !bNow)//	{//		ALERT(at_console,"Setting LinearMoveNow to happen after %f/n",gpGlobals->time);		SetThink(&CBaseToggle :: LinearMoveNow );		UTIL_DesiredThink( this );		//pev->nextthink = pev->ltime + 0.01;//	}//	else//	{//		LinearMoveNow(); // starring Martin Sheen and Marlon Brando//	}}

//-----------------------------------------------------------------------------// Purpose: Called when spawning, after keyvalues have been handled.//-----------------------------------------------------------------------------void CASW_Use_Area::Spawn( void ){	m_bUseAreaEnabled = !m_bDisabled;	m_bDisabled = false;	// don't allow normal triggerish disabling	BaseClass::Spawn();	InitTrigger();	if (m_flWait <= 0)	{				m_flWait = 0.2;	}		ASSERTSZ(m_iHealth == 0, "trigger_multiple with health");			AddEFlags( EFL_FORCE_CHECK_TRANSMIT );		// find the target this use area is attached to	m_hUseTarget = gEntList.FindEntityByName(NULL, m_iUseTargetName, NULL);	//Assert(!m_hUseTarget);	m_hPanelProp = gEntList.FindEntityByName( NULL, m_szPanelPropName );		m_bMultiplePanelProps = gEntList.FindEntityByName( m_hPanelProp.Get(), m_szPanelPropName ) != NULL;}

CInOutRegister *CInOutRegister::Prune( void ){	if ( m_hValue )	{		ASSERTSZ(m_pNext != NULL, "invalid InOut registry terminator/n");		if ( m_pField->Intersects(m_hValue) )		{			// this entity is still inside the field, do nothing			m_pNext = m_pNext->Prune();			return this;		}		else		{			// this entity has just left the field, trigger			m_pField->FireOnLeave( m_hValue );			SetThink( Remove );			SetNextThink( 0.1 );			return m_pNext->Prune();		}	}	else	{	// this register has a missing or null value		if (m_pNext)		{			// this is an invalid list entry, remove it			SetThink( Remove );			SetNextThink( 0.1 );			return m_pNext->Prune();		}		else		{			// this is the list terminator, leave it.			return this;		}	}}

void CRotDoor :: Spawn( void ){	// set the axis of rotation	AxisDir( pev );	if( FBitSet( pev->spawnflags, SF_DOOR_PASSABLE ))		pev->solid = SOLID_NOT;	else pev->solid = SOLID_BSP;	Precache();	// check for clockwise rotation	if( FBitSet( pev->spawnflags, SF_DOOR_ROTATE_BACKWARDS ))		pev->movedir = pev->movedir * -1;		m_vecAngle1 = GetLocalAngles();	m_vecAngle2 = GetLocalAngles() + pev->movedir * m_flMoveDistance;	ASSERTSZ( m_vecAngle1 != m_vecAngle2, "rotating door start/end positions are equal" );	pev->movetype = MOVETYPE_PUSH;	SET_MODEL( edict(), GetModel() );	// NOTE: original Half-Life was contain a bug in AngularMove function	// while m_flWait was equal 0 then object has stopped forever. See code from quake:	/*		void AngularMove( Vector vecDest, float flSpeed )		{			...			...			...			if( flTravelTime < 0.1f )			{				pev->avelocity = g_vecZero;				pev->nextthink = pev->ltime + 0.1f;				return;			}		}	*/	// this block was removed from Half-Life and there no difference	// between wait = 0 and wait = -1. But in Xash this bug was fixed	// and level-designer errors is now actual. I'm set m_flWait to -1 for compatibility	if( m_flWait == 0.0f )		m_flWait = -1;	if( pev->speed == 0 )		pev->speed = 100;		// DOOR_START_OPEN is to allow an entity to be lighted in the closed position	// but spawn in the open position	if( FBitSet( pev->spawnflags, SF_DOOR_START_OPEN ))	{		// swap pos1 and pos2, put door at pos2, invert movement direction		Vector vecNewAngles = m_vecAngle2;		m_vecAngle2 = m_vecAngle1;		m_vecAngle1 = vecNewAngles;		pev->movedir = pev->movedir * -1;		// We've already had our physics setup in BaseClass::Spawn, so teleport to our		// current position. If we don't do this, our vphysics shadow will not update.		Teleport( NULL, &m_vecAngle1, NULL );	}	else	{		SetLocalAngles( m_vecAngle1 );	}	m_iState = STATE_OFF;	RelinkEntity();	m_pUserData = WorldPhysic->CreateKinematicBodyFromEntity( this );	if( FBitSet( pev->spawnflags, SF_DOOR_USE_ONLY ))	{		SetTouch( NULL );	}	else	{		// touchable button		SetTouch( DoorTouch );	}}

void CBaseDoor::Spawn( void ){	if( pev->skin == CONTENTS_NONE )	{		// normal door		if( FBitSet( pev->spawnflags, SF_DOOR_PASSABLE ))			pev->solid = SOLID_NOT;		else			pev->solid = SOLID_BSP;	}	else	{		SetBits( pev->spawnflags, SF_DOOR_SILENT );		pev->solid = SOLID_NOT; // special contents	}	Precache();	pev->movetype = MOVETYPE_PUSH;	SET_MODEL( edict(), GetModel() );	// NOTE: original Half-Life was contain a bug in LinearMove function	// while m_flWait was equal 0 then object has stopped forever. See code from quake:	/*		void LinearMove( Vector vecDest, float flSpeed )		{			...			...			...			if( flTravelTime < 0.1f )			{				pev->velocity = g_vecZero;				pev->nextthink = pev->ltime + 0.1f;				return;			}		}	*/	// this block was removed from Half-Life and there no difference	// between wait = 0 and wait = -1. But in Xash this bug was fixed	// and level-designer errors is now actual. I'm set m_flWait to -1 for compatibility	if( m_flWait == 0.0f )		m_flWait = -1;	if( pev->speed == 0 )		pev->speed = 100;	if( pev->movedir == g_vecZero )		pev->movedir = Vector( 1.0f, 0.0f, 0.0f );	m_vecPosition1 = GetLocalOrigin();	// Subtract 2 from size because the engine expands bboxes by 1 in all directions making the size too big	Vector vecSize = pev->size - Vector( 2, 2, 2 );	m_vecPosition2 = m_vecPosition1 + (pev->movedir * (DotProductAbs( pev->movedir, vecSize ) - m_flLip));	ASSERTSZ( m_vecPosition1 != m_vecPosition2, "door start/end positions are equal" );	if( FBitSet( pev->spawnflags, SF_DOOR_START_OPEN ))	{			UTIL_SetOrigin( this, m_vecPosition2 );		m_vecPosition2 = m_vecPosition1;		m_vecPosition1 = GetLocalOrigin();	}	else	{		UTIL_SetOrigin( this, m_vecPosition1 );	}	// another hack: PhysX 2.8.4.0 crashed while trying to created kinematic body from this brush-model	if ( FStrEq( STRING( gpGlobals->mapname ), "c2a5e" ) && FStrEq( STRING( pev->model ), "*103" ));	else m_pUserData = WorldPhysic->CreateKinematicBodyFromEntity( this );	m_iState = STATE_OFF;	// if the door is flagged for USE button activation only, use NULL touch function	if( FBitSet( pev->spawnflags, SF_DOOR_USE_ONLY ))	{		SetTouch( NULL );	}	else	{		// touchable button		SetTouch( DoorTouch );	}}

void CPathCorner :: Spawn( ){	ASSERTSZ(!FStringNull(pev->targetname), "path_corner without a targetname");}

//-----------------------------------------------------------------------------// Purpose: //-----------------------------------------------------------------------------void CPathCorner::Spawn( void ){	ASSERTSZ(GetEntityName() != NULL_STRING, "path_corner without a targetname");}

void CRotButton::Spawn( void ){	//----------------------------------------------------	//determine sounds for buttons	//a sound of 0 should not make a sound	//----------------------------------------------------	if ( m_sounds )	{		m_sNoise = MakeButtonSound( m_sounds );		PrecacheScriptSound(m_sNoise.ToCStr());	}	else	{		m_sNoise = NULL_STRING;	}	// set the axis of rotation	CBaseToggle::AxisDir();	// check for clockwise rotation	if ( HasSpawnFlags( SF_DOOR_ROTATE_BACKWARDS) )	{		m_vecMoveAng = m_vecMoveAng * -1;	}	SetMoveType( MOVETYPE_PUSH );	#ifdef HL1_DLL	SetSolid( SOLID_BSP );#else	SetSolid( SOLID_VPHYSICS );#endif	if ( HasSpawnFlags( SF_ROTBUTTON_NOTSOLID ) )	{		AddEFlags( EFL_USE_PARTITION_WHEN_NOT_SOLID );		AddSolidFlags( FSOLID_NOT_SOLID );	}	SetModel( STRING( GetModelName() ) );		if (m_flSpeed == 0)		m_flSpeed = 40;	if (m_flWait == 0)		m_flWait = 1;	if (m_iHealth > 0)	{		m_takedamage = DAMAGE_YES;	}	m_toggle_state = TS_AT_BOTTOM;	m_vecAngle1	= GetLocalAngles();	m_vecAngle2	= GetLocalAngles() + m_vecMoveAng * m_flMoveDistance;	ASSERTSZ(m_vecAngle1 != m_vecAngle2, "rotating button start/end positions are equal/n");	m_fStayPushed = (m_flWait == -1 ? TRUE : FALSE);	m_fRotating = TRUE;	SetUse(&CRotButton::ButtonUse);	//	// If touching activates the button, set its touch function.	//	if (!HasSpawnFlags(SF_BUTTON_TOUCH_ACTIVATES))	{		SetTouch ( NULL );	}	else	{		SetTouch( &CRotButton::ButtonTouch );	}	CreateVPhysics();}