コード例 #1
0
ファイル: Trigger.cpp プロジェクト: tankorsmash/quadcow
/*
================
idTrigger_EntityName::Event_Trigger

the trigger was just activated
activated should be the entity that originated the activation sequence (ie. the original target)
activator should be set to the activator so it can be held through a delay
so wait for the delay time before firing
================
*/
void idTrigger_EntityName::Event_Trigger( idEntity *activator ) {
	if ( nextTriggerTime > gameLocal.time ) {
		// can't retrigger until the wait is over
		return;
	}

	if ( !activator || ( activator->name != entityName ) ) {
		return;
	}

	if ( triggerFirst ) {
		triggerFirst = false;
		return;
	}

	// don't allow it to trigger twice in a single frame
	nextTriggerTime = gameLocal.time + 1;

	if ( delay > 0 ) {
		// don't allow it to trigger again until our delay has passed
		nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
		PostEventSec( &EV_TriggerAction, delay, activator );
	} else {
		TriggerAction( activator );
	}
}
コード例 #2
0
ファイル: Trigger.cpp プロジェクト: ET-NiK/amxxgroup
/*
================
idTrigger_EntityName::Event_Touch
================
*/
void idTrigger_EntityName::Event_Touch( idEntity *other, trace_t *trace ) {
    if( triggerFirst ) {
        return;
    }

    if ( nextTriggerTime > gameLocal.time ) {
        // can't retrigger until the wait is over
        return;
    }

// RAVEN BEGIN
// abahr: so we can exclude an entity by name
    if( !other ) {
        return;
    }

    if( spawnArgs.GetBool("excludeEntityName") && other->name == entityName ) {
        return;
    }

    if( !spawnArgs.GetBool("excludeEntityName") && other->name != entityName ) {
        return;
    }
// RAVEN END

    nextTriggerTime = gameLocal.time + 1;
    if ( delay > 0 ) {
        // don't allow it to trigger again until our delay has passed
        nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
        PostEventSec( &EV_TriggerAction, delay, other );
    } else {
        TriggerAction( other );
    }
}
コード例 #3
0
ファイル: Trigger.cpp プロジェクト: ET-NiK/amxxgroup
/*
================
idTrigger_Multi::Event_Trigger

the trigger was just activated
activated should be the entity that originated the activation sequence (ie. the original target)
activator should be set to the activator so it can be held through a delay
so wait for the delay time before firing
================
*/
void idTrigger_Multi::Event_Trigger( idEntity *activator ) {
// RAVEN BEGIN
// bdube: moved trigger first
    if ( triggerFirst ) {
        triggerFirst = false;
        return;
    }

    if ( nextTriggerTime > gameLocal.time ) {
        // can't retrigger until the wait is over
        return;
    }

    // see if this trigger requires an item
    if ( !gameLocal.RequirementMet( activator, requires, removeItem ) ) {
        return;
    }

    if ( !CheckFacing( activator ) ) {
        return;
    }
// RAVEN END

    // don't allow it to trigger twice in a single frame
    nextTriggerTime = gameLocal.time + 1;

    if ( delay > 0 ) {
        // don't allow it to trigger again until our delay has passed
        nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
        PostEventSec( &EV_TriggerAction, delay, activator );
    } else {
        TriggerAction( activator );
    }
}
コード例 #4
0
ファイル: Trigger.cpp プロジェクト: revelator/MHDoom
/*
================
idTrigger_EntityName::Event_Touch
================
*/
void idTrigger_EntityName::Event_Touch( idEntity *other, trace_t *trace )
{
	if( triggerFirst )
	{
		return;
	}
	
	if( nextTriggerTime > gameLocal.time )
	{
		// can't retrigger until the wait is over
		return;
	}
	
	if( !other || ( other->name != entityName ) )
	{
		return;
	}
	
	nextTriggerTime = gameLocal.time + 1;
	if( delay > 0 )
	{
		// don't allow it to trigger again until our delay has passed
		nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
		PostEventSec( &EV_TriggerAction, delay, other );
	}
	else
	{
		TriggerAction( other );
	}
}
コード例 #5
0
ファイル: Trigger.cpp プロジェクト: revelator/MHDoom
/*
================
idTrigger_Multi::Event_Touch
================
*/
void idTrigger_Multi::Event_Touch( idEntity *other, trace_t *trace )
{
	if( triggerFirst )
	{
		return;
	}
	
	bool player = other->IsType( idPlayer::Type );
	if( player )
	{
		if( !touchClient )
		{
			return;
		}
		if( static_cast< idPlayer * >( other )->spectating )
		{
			return;
		}
	}
	else if( !touchOther )
	{
		return;
	}
	
	if( nextTriggerTime > gameLocal.time )
	{
		// can't retrigger until the wait is over
		return;
	}
	
	// see if this trigger requires an item
	if( !gameLocal.RequirementMet( other, requires, removeItem ) )
	{
		return;
	}
	
	if( !CheckFacing( other ) )
	{
		return;
	}
	
	if( spawnArgs.GetBool( "toggleTriggerFirst" ) )
	{
		triggerFirst = true;
	}
	
	nextTriggerTime = gameLocal.time + 1;
	if( delay > 0 )
	{
		// don't allow it to trigger again until our delay has passed
		nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
		PostEventSec( &EV_TriggerAction, delay, other );
	}
	else
	{
		TriggerAction( other );
	}
}
コード例 #6
0
/*
================
idTrigger_EntityName::Event_Touch
================
*/
void idTrigger_EntityName::Event_Touch( idEntity* other, trace_t* trace )
{
	if( common->IsClient() )
	{
		return;
	}
	
	if( triggerFirst )
	{
		return;
	}
	
	if( nextTriggerTime > gameLocal.time )
	{
		// can't retrigger until the wait is over
		return;
	}
	
	bool validEntity = false;
	if( other )
	{
		if( testPartialName )
		{
			if( other->name.Find( entityName, false ) >= 0 )
			{
				validEntity = true;
			}
		}
		if( other->name == entityName )
		{
			validEntity = true;
		}
	}
	
	if( !validEntity )
	{
		return;
	}
	
	nextTriggerTime = gameLocal.time + 1;
	if( delay > 0 )
	{
		// don't allow it to trigger again until our delay has passed
		nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
		PostEventSec( &EV_TriggerAction, delay, other );
	}
	else
	{
		TriggerAction( other );
	}
}
コード例 #7
0
/**
 * Check whether the watchdog timer is running and trigger proper action 
 * 
 * @return true if thread can exit, false if not
 **/
bool NewSimulatorWatchdog::TriggerAction() {
   
   stdlog << "DBG: CheckWatchdogTimer\n";
    
   if ( m_wdt_data.Running == SAHPI_FALSE )
      return true;
      
   if ( ! m_start.IsSet() )
      return true;
   
   // Ok, we have a running wdt
   cTime now( cTime::Now() );
   now -= m_start;
   
   if ( now.GetMsec() >= m_wdt_data.InitialCount ) {
   	  
   	  if ( m_state != PRETIMEOUT )
   	     TriggerAction( PRETIMEOUT );
      TriggerAction( TIMEOUT );
      
      stdlog << "DBG: WatchdogTimer expires.\n";
      
      return true;
   }
   
   if ( now.GetMsec() >= m_wdt_data.InitialCount - m_wdt_data.PreTimeoutInterval ) {
   	
   	  TriggerAction( PRETIMEOUT );
   	  
   	  return false;
   }
   
   m_wdt_data.PresentCount = m_wdt_data.InitialCount - now.GetMsec();

   return false;
}
コード例 #8
0
ファイル: Trigger.cpp プロジェクト: tankorsmash/quadcow
/*
================
idTrigger_Multi::Event_Trigger

the trigger was just activated
activated should be the entity that originated the activation sequence (ie. the original target)
activator should be set to the activator so it can be held through a delay
so wait for the delay time before firing
================
*/
void idTrigger_Multi::Event_Trigger( idEntity *activator ) {
	if ( nextTriggerTime > gameLocal.time ) {
		// can't retrigger until the wait is over
		return;
	}

	// see if this trigger requires an item
	if ( !gameLocal.RequirementMet( activator, requires, removeItem ) ) {
		return;
	}

	if ( !CheckFacing( activator ) ) {
		return;
	}

	if ( triggerFirst ) {
		triggerFirst = false;
		return;
	}

	// don't allow it to trigger twice in a single frame
	nextTriggerTime = gameLocal.time + 1;

	if ( delay > 0 ) {
		// don't allow it to trigger again until our delay has passed
		nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
		PostEventSec( &EV_TriggerAction, delay, activator );
	} else {
		TriggerAction( activator );
	}


	//BC recording.
	idEntity *recordEnt;
	recordEnt = gameLocal.FindEntity( "world1" );
	if (recordEnt)
	{
		if (this->spawnArgs.GetBool("recordable", "0"))
		{
			static_cast<idWorldManager *>( recordEnt )->RecordFrob(this->GetName());
		}
	}
}
コード例 #9
0
ファイル: Trigger.cpp プロジェクト: tankorsmash/quadcow
/*
================
idTrigger_EntityName::Event_Touch
================
*/
void idTrigger_classname::Event_Touch( idEntity *other, trace_t *trace )
{
	if( triggerFirst )
	{
		return;
	}

	if ( nextTriggerTime > gameLocal.time )
	{
		// can't retrigger until the wait is over
		return;
	}

	
	if ( !other || ( other->spawnArgs.GetString("classname") != className ) )
	{
		return;
	}

	nextTriggerTime = gameLocal.time + 1;

	TriggerAction( other );
}
コード例 #10
0
ファイル: Trigger.cpp プロジェクト: ET-NiK/amxxgroup
/*
================
idTrigger_EntityName::Event_Trigger

the trigger was just activated
activated should be the entity that originated the activation sequence (ie. the original target)
activator should be set to the activator so it can be held through a delay
so wait for the delay time before firing
================
*/
void idTrigger_EntityName::Event_Trigger( idEntity *activator ) {
    if ( nextTriggerTime > gameLocal.time ) {
        // can't retrigger until the wait is over
        return;
    }

// RAVEN BEGIN
// abahr: so we can exclude an entity by name
    if( !activator ) {
        return;
    }

    if( spawnArgs.GetBool("excludeEntityName") && activator->name == entityName ) {
        return;
    }

    if( !spawnArgs.GetBool("excludeEntityName") && activator->name != entityName ) {
        return;
    }
// RAVEN END

    if ( triggerFirst ) {
        triggerFirst = false;
        return;
    }

    // don't allow it to trigger twice in a single frame
    nextTriggerTime = gameLocal.time + 1;

    if ( delay > 0 ) {
        // don't allow it to trigger again until our delay has passed
        nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
        PostEventSec( &EV_TriggerAction, delay, activator );
    } else {
        TriggerAction( activator );
    }
}
コード例 #11
0
ファイル: Trigger.cpp プロジェクト: ET-NiK/amxxgroup
// RAVEN BEGIN
// kfuller:
void idTrigger_Multi::Event_EarthQuake(float requiresLOS)
{
    // does this entity even care about earthquakes?
    float	quakeChance = 0;

    if (!spawnArgs.GetFloat("quakeChance", "0", quakeChance))
    {
        return;
    }
    if (rvRandom::flrand(0, 1.0f) > quakeChance)
    {
        // failed its activation roll
        return;
    }
    if (requiresLOS)
    {
        // if the player doesn't have line of sight to this fx, don't do anything
        trace_t		trace;
        idPlayer	*player = gameLocal.GetLocalPlayer();
        idVec3		viewOrigin;
        idMat3		viewAxis;

        player->GetViewPos(viewOrigin, viewAxis);
// RAVEN BEGIN
// ddynerman: multiple clip worlds
        gameLocal.TracePoint( this, trace, viewOrigin, GetPhysics()->GetOrigin(), MASK_OPAQUE, player );
// RAVEN END
        if (trace.fraction < 1.0f)
        {
            // something blocked LOS
            return;
        }
    }
    // activate this effect now
    TriggerAction(gameLocal.entities[ENTITYNUM_WORLD]);
}
コード例 #12
0
ファイル: Trigger.cpp プロジェクト: tankorsmash/quadcow
void idTrigger_classname::Event_Trigger( idEntity *activator )
{
	if ( nextTriggerTime > gameLocal.time )
	{
		// can't retrigger until the wait is over
		return;
	}

	if ( !activator || ( activator->spawnArgs.GetString("classname") != className ) )
	{
		return;
	}
	
	if ( triggerFirst )
	{
		triggerFirst = false;
		return;
	}

	// don't allow it to trigger twice in a single frame
	nextTriggerTime = gameLocal.time + 1;

	TriggerAction( activator );
}
コード例 #13
0
ファイル: Trigger.cpp プロジェクト: ET-NiK/amxxgroup
/*
================
idTrigger_EntityName::Event_TriggerAction
================
*/
void idTrigger_EntityName::Event_TriggerAction( idEntity *activator ) {
    TriggerAction( activator );
}
コード例 #14
0
ファイル: Trigger.cpp プロジェクト: ET-NiK/amxxgroup
/*
================
idTrigger_Multi::Event_Touch
================
*/
void idTrigger_Multi::Event_Touch( idEntity *other, trace_t *trace ) {
    if( triggerFirst ) {
        return;
    }

// RAVEN BEGIN
// jdischler: vehicle only trigger
    if ( touchVehicle ) {
        if ( !other->IsType(rvVehicle::GetClassType()) ) {
            return;
        }
    } else {
// RAVEN BEGIN
// jnewquist: Use accessor for static class type
        bool player = other->IsType( idPlayer::GetClassType() );
// RAVEN END
        if ( player ) {
            if ( !touchClient ) {
                return;
            }
            if ( static_cast< idPlayer * >( other )->spectating ) {
                return;
            }

            // Buy zone handling
            if ( buyZoneTrigger /*&& gameLocal.mpGame.mpGameState.gameState.currentState != 1*/ ) {
                idPlayer *p = static_cast< idPlayer * >( other );
                if ( buyZoneTrigger-1 == p->team || buyZoneTrigger == 3)
                {
                    p->inBuyZone = true;
                    p->inBuyZonePrev = true;
                }
            }

            // Control zone handling
            if ( controlZoneTrigger > 0 ) {
                idPlayer *p = static_cast< idPlayer * >( other );
                if ( p->PowerUpActive(POWERUP_DEADZONE) || !spawnArgs.GetBool("requiresDeadZonePowerup", "1") )
                    playersInTrigger.Append(p);
            }

        } else if ( !touchOther ) {
            return;
        }
    }

    if ( nextTriggerTime > gameLocal.time ) {
        // can't retrigger until the wait is over
        return;
    }

    // see if this trigger requires an item
    if ( !gameLocal.RequirementMet( other, requires, removeItem ) ) {
        return;
    }

    if ( !CheckFacing( other ) ) {
        return;
    }

    if ( spawnArgs.GetBool( "toggleTriggerFirst" ) ) {
        triggerFirst = true;
    }

// RAVEN BEGIN
// rjohnson: added block
    if ( developer.GetBool() && *spawnArgs.GetString ( "message" ) ) {
        gameLocal.DPrintf ( "Trigger: %s\n", spawnArgs.GetString ( "message" ) );
    }
// RAVEN END

    nextTriggerTime = gameLocal.time + 1;
    if ( delay > 0 ) {
        // don't allow it to trigger again until our delay has passed
        nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
        PostEventSec( &EV_TriggerAction, delay, other );
    } else {
        TriggerAction( other );
    }
}
コード例 #15
0
ファイル: Trigger.cpp プロジェクト: ET-NiK/amxxgroup
/*
================
idTrigger_Multi::Event_TriggerAction
================
*/
void idTrigger_Multi::Event_TriggerAction( idEntity *activator ) {
    TriggerAction( activator );
}
コード例 #16
0
ファイル: Trigger.cpp プロジェクト: tankorsmash/quadcow
/*
================
idTrigger_EntityName::Event_Touch
================
*/
void idTrigger_EntityName::Event_Touch( idEntity *other, trace_t *trace ) {
	if( triggerFirst ) {
		return;
	}

	if ( nextTriggerTime > gameLocal.time ) {
		// can't retrigger until the wait is over
		return;
	}

	if ( !other || ( other->name != entityName ) ) {
		return;
	}

	nextTriggerTime = gameLocal.time + 1;
	if ( delay > 0 )
	{
		// don't allow it to trigger again until our delay has passed
		nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
		PostEventSec( &EV_TriggerAction, delay, other );
	}
	else
	{

		//bc this is VERY car-specific hack to ensure all four corners of the car are within the "hidey" trigger.
		if ( other->IsType( idActivator::Type ) )
		{
			idAngles otherAngles;
			idVec3 size;
			idVec3 forward;
			idVec3 right;

			other->spawnArgs.GetVector( "size", "0 0 0", size );

			if (size.x != 0 && size.y != 0 && size.z != 0)
			{
				otherAngles = other->GetPhysics()->GetAxis().ToAngles();
				forward = otherAngles.ToForward();
				otherAngles.yaw += 90;
				right = otherAngles.ToForward();

				idVec3 frontLeft = other->GetPhysics()->GetAbsBounds().GetCenter() + forward * (size.x/2) + right * (size.y/2);
				idVec3 frontRight = other->GetPhysics()->GetAbsBounds().GetCenter() + forward * (size.x/2) + right * -(size.y/2);

				idVec3 rearLeft = other->GetPhysics()->GetAbsBounds().GetCenter() + forward * -(size.x/2) + right * (size.y/2);
				idVec3 rearRight = other->GetPhysics()->GetAbsBounds().GetCenter() + forward * -(size.x/2) + right * -(size.y/2);


				/*
				gameRenderWorld->DebugCircle( colorWhite, frontLeft, idVec3(0,0,1), 4, 6, 500 );
				gameRenderWorld->DebugCircle( colorWhite, frontRight, idVec3(0,0,1), 4, 6, 500 );
				gameRenderWorld->DebugCircle( colorWhite, rearLeft, idVec3(0,0,1), 4, 6, 500 );
				gameRenderWorld->DebugCircle( colorWhite, rearRight, idVec3(0,0,1), 4, 6, 500 );
				*/

				if (!this->GetPhysics()->GetAbsBounds().ContainsPoint( frontLeft)
					|| !this->GetPhysics()->GetAbsBounds().ContainsPoint( frontRight)
					|| !this->GetPhysics()->GetAbsBounds().ContainsPoint( rearLeft)
					|| !this->GetPhysics()->GetAbsBounds().ContainsPoint( rearRight))
				{
					return;
				}
				else
				{
					//inside the trigger.
					idEntity *carMaster = gameLocal.FindEntity( other->spawnArgs.GetString( "master" ) );

					if (carMaster)
					{	
						gameLocal.GetLocalPlayer()->UseFrob( carMaster, "inEntTrigger" );
						TriggerAction( other );
						return;
					}

					return;
				}

			}
		}

		TriggerAction( other );
	}
}
コード例 #17
0
ファイル: Trigger.cpp プロジェクト: tankorsmash/quadcow
/*
================
idTrigger_Multi::Event_Touch
================
*/
void idTrigger_Multi::Event_Touch( idEntity *other, trace_t *trace ) {
	if( triggerFirst ) {
		return;
	}

	bool player = other->IsType( idPlayer::Type );
	if ( player ) {
		if ( !touchClient ) {
			return;
		}
		if ( static_cast< idPlayer * >( other )->spectating ) {
			return;
		}
	} else if ( !touchOther ) {
		return;
	}

	if ( nextTriggerTime > gameLocal.time ) {
		// can't retrigger until the wait is over
		return;
	}

	// see if this trigger requires an item
	if ( !gameLocal.RequirementMet( other, requires, removeItem ) ) {
		return;
	}

	if ( !CheckFacing( other ) ) {
		return;
	}

	if ( spawnArgs.GetBool( "toggleTriggerFirst" ) ) {
		triggerFirst = true;
	}

	if (player && spawnArgs.GetBool( "falltrigger" ))
	{
		StartSound(  "snd_camerasnap" , SND_CHANNEL_ANY, 0, false, NULL );
		

		

		if (gameLocal.GetLocalPlayer()->inDeck)
		{
			//kick player out of deck.
			//cvarSystem->SetCVarBool("deckActive", true, 0);
			//gameLocal.GetLocalPlayer()->deckEnt.GetEntity()->GetPhysics()->SetOrigin(popcornpos);
			
			//gameLocal.sessionCommand = "stopgui";


			
			gameLocal.GetLocalPlayer()->ExitDeck(true);
		}


		const char *manualPos = this->spawnArgs.GetString("target");
		if (manualPos)
		{
			idEntity *manualEnt = gameLocal.FindEntity( manualPos );
			if (manualEnt)
			{
				other->SetOrigin( manualEnt->GetPhysics()->GetOrigin() + idVec3(0,0,1) );
				other->GetPhysics()->PutToRest();
				return;
			}
		}


		//current.velocity.Zero();

		idVec3 popcornpos = static_cast< idPlayer * >( other )->popcornPosition;
		

		if (popcornpos == vec3_zero)
		{
			//no valid popcorn position.

			//reset player to spawn point.
			int spawnIndex = 0;
			idEntity *recordEnt;
			recordEnt = gameLocal.FindEntity( "world1" );
			if (recordEnt)
			{
				spawnIndex = static_cast<idWorldManager *>( recordEnt )->index;
			}

			idEntity *spawnEnt;
			spawnEnt = gameLocal.FindEntity( va("heliinsertion%d", spawnIndex) );
			
			if (spawnEnt)
			{
				other->SetOrigin( spawnEnt->GetPhysics()->GetOrigin() + idVec3(0,0,1) );
				other->GetPhysics()->PutToRest();
			}
		}
		else
		{
			other->SetOrigin( popcornpos + idVec3(0,0,1) );
			other->GetPhysics()->PutToRest();
		}
	}

	nextTriggerTime = gameLocal.time + 1;
	if ( delay > 0 ) {
		// don't allow it to trigger again until our delay has passed
		nextTriggerTime += SEC2MS( delay + random_delay * gameLocal.random.CRandomFloat() );
		PostEventSec( &EV_TriggerAction, delay, other );
	} else {
		TriggerAction( other );
	}
}