bool CItem::CreateItemVPhysicsObject( void )
{
// Create the object in the physics system
int nSolidFlags = GetSolidFlags() | FSOLID_NOT_STANDABLE;
if ( !m_bActivateWhenAtRest )
{
nSolidFlags |= FSOLID_TRIGGER;
}
if ( VPhysicsInitNormal( SOLID_VPHYSICS, nSolidFlags, false ) == NULL )
{
SetSolid( SOLID_BBOX );
AddSolidFlags( nSolidFlags );
// If it's not physical, drop it to the floor
if (UTIL_DropToFloor(this, MASK_SOLID) == 0)
{
Warning( "Item %s fell out of level at %f,%f,%f\n", GetClassname(), GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z);
UTIL_Remove( this );
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Make the weapon visible and tangible
//-----------------------------------------------------------------------------
CBaseEntity* CBaseCombatWeapon::Respawn( void )
{
// make a copy of this weapon that is invisible and inaccessible to players (no touch function). The weapon spawn/respawn code
// will decide when to make the weapon visible and touchable.
CBaseEntity *pNewWeapon = CBaseEntity::Create( GetClassname(), g_pGameRules->VecWeaponRespawnSpot( this ), GetLocalAngles(), GetOwnerEntity() );
if ( pNewWeapon )
{
pNewWeapon->AddEffects( EF_NODRAW );// invisible for now
pNewWeapon->SetTouch( NULL );// no touch
pNewWeapon->SetThink( &CBaseCombatWeapon::AttemptToMaterialize );
UTIL_DropToFloor( this, MASK_SOLID );
// not a typo! We want to know when the weapon the player just picked up should respawn! This new entity we created is the replacement,
// but when it should respawn is based on conditions belonging to the weapon that was taken.
pNewWeapon->SetNextThink( gpGlobals->curtime + g_pGameRules->FlWeaponRespawnTime( this ) );
}
else
{
Warning("Respawn failed to create %s!\n", GetClassname() );
}
return pNewWeapon;
}
void Spawn( void )
{
m_bRespawn = true;
Precache();
SetModel( "models/items/battery.mdl" );
BaseClass::Spawn( );
UTIL_DropToFloor( this, MASK_SOLID );
}
void CHL1Item::Activate( void )
{
BaseClass::Activate();
if ( UTIL_DropToFloor( this, MASK_SOLID ) == 0 )
{
Warning( "Item %s fell out of level at %f,%f,%f\n", GetClassname(), GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z);
UTIL_Remove( this );
return;
}
}
void CCombatWeapon::Spawn()
{
if(m_bRemoveOnDrop)
{
m_bRespawn = false;
}
BaseClass::Spawn();
if(m_bRespawn)
{
UTIL_DropToFloor( this, MASK_SOLID );
}
}
bool CDirector_Manager::AddBoss(const Vector &vecPosition)
{
// No se ha podido acceder al Director.
if ( !Director() )
return false;
// No es posible crear un jefe aquí.
if ( !CanMake(vecPosition) )
return false;
// Creamos un jefe de la lista.
const char *pBossName = GetBossClass();
CAI_BaseNPC *pBoss = (CAI_BaseNPC *)CreateEntityByName(pBossName);
QAngle angles = RandomAngle(0, 360);
angles.x = 0.0;
angles.z = 0.0;
pBoss->SetAbsAngles(angles);
// Establecemos la ubicación de creación.
pBoss->SetAbsOrigin(vecPosition);
// Debe caer al suelo y desaparecer.
pBoss->AddSpawnFlags(SF_NPC_FALL_TO_GROUND);
UTIL_DropToFloor(pBoss, MASK_SOLID);
ConVarRef director_debug("director_debug");
// Marcamos al nodo afortunado.
if ( director_debug.GetBool() )
NDebugOverlay::Box(vecPosition, -Vector(15, 15, 15), Vector(15, 15, 15), 223, 1, 1, 10, 3.0f);
DispatchSpawn(pBoss);
pBoss->SetOwnerEntity(Director());
DispatchActivate(pBoss);
// ¡¡NO CAMBIAR!!
pBoss->SetName(MAKE_STRING(BOSS_NAME));
// Al parecer se atoro en una pared.
if ( !PostSpawn(pBoss) )
return false;
DevMsg("[MANAGER] Se ha creado un JEFE. \r\n");
++Director()->BossSpawned;
Director()->BossPendient = false;
Director()->ChildsKilled = 0;
return true;
}
void CItem::Spawn( void )
{
pev->movetype = MOVETYPE_TOSS;
pev->solid = SOLID_TRIGGER;
SetAbsOrigin( GetAbsOrigin() );
SetSize( Vector( -16, -16, 0 ), Vector( 16, 16, 16 ) );
SetTouch( &CItem::ItemTouch );
if( UTIL_DropToFloor( this ) == DropToFloor::TOOFAR )
{
ALERT( at_error, "Item %s fell out of level at %f,%f,%f", GetClassname(), GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z );
UTIL_Remove( this );
return;
}
}
CBaseEntity* CASW_Spawn_Manager::SpawnAlienAt(const char* szAlienClass, const Vector& vecPos, const QAngle &angle)
{
CBaseEntity *pEntity = NULL;
pEntity = CreateEntityByName( szAlienClass );
CAI_BaseNPC *pNPC = dynamic_cast<CAI_BaseNPC*>(pEntity);
if ( pNPC )
{
pNPC->AddSpawnFlags( SF_NPC_FALL_TO_GROUND );
}
// Strip pitch and roll from the spawner's angles. Pass only yaw to the spawned NPC.
QAngle angles = angle;
angles.x = 0.0;
angles.z = 0.0;
pEntity->SetAbsOrigin( vecPos );
pEntity->SetAbsAngles( angles );
if (strcmp("asw_buzzer", szAlienClass) != 0) {
UTIL_DropToFloor( pEntity, MASK_SOLID );
}
IASW_Spawnable_NPC* pSpawnable = dynamic_cast<IASW_Spawnable_NPC*>(pEntity);
ASSERT(pSpawnable);
if ( !pSpawnable )
{
Warning("NULL Spawnable Ent in CASW_Spawn_Manager::SpawnAlienAt! AlienClass = %s\n", szAlienClass);
UTIL_Remove(pEntity);
return NULL;
}
// have drones unburrow by default, so we don't worry so much about them spawning onscreen
if ( !Q_strcmp( szAlienClass, "asw_drone" ) )
{
pSpawnable->StartBurrowed();
pSpawnable->SetUnburrowIdleActivity( NULL_STRING );
pSpawnable->SetUnburrowActivity( NULL_STRING );
}
DispatchSpawn( pEntity );
pEntity->Activate();
// give our aliens the orders
pSpawnable->SetAlienOrders(AOT_MoveToNearestMarine, vec3_origin, NULL);
return pEntity;
}
CBaseEntity* CItem::Respawn( void )
{
SetTouch( NULL );
AddEffects( EF_NODRAW );
VPhysicsDestroyObject();
SetMoveType( MOVETYPE_NONE );
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_TRIGGER );
UTIL_SetOrigin( this, g_pGameRules->VecItemRespawnSpot( this ) );// blip to whereever you should respawn.
SetAbsAngles( g_pGameRules->VecItemRespawnAngles( this ) );// set the angles.
UTIL_DropToFloor( this, MASK_SOLID );
RemoveAllDecals(); //remove any decals
SetThink ( &CItem::Materialize );
SetNextThink( gpGlobals->curtime + g_pGameRules->FlItemRespawnTime( this ) );
return this;
}
void CWeaponHL2MPBase::FallInit( void )
{
#ifndef CLIENT_DLL
SetModel( GetWorldModel() );
VPhysicsDestroyObject();
if ( HasSpawnFlags( SF_NORESPAWN ) == false )
{
SetMoveType( MOVETYPE_NONE );
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_TRIGGER );
UTIL_DropToFloor( this, MASK_SOLID );
}
else
{
if ( !VPhysicsInitNormal( SOLID_BBOX, GetSolidFlags() | FSOLID_TRIGGER, false ) )
{
SetMoveType( MOVETYPE_NONE );
SetSolid( SOLID_BBOX );
AddSolidFlags( FSOLID_TRIGGER );
}
else
{
#if !defined( CLIENT_DLL )
// Constrained start?
if ( HasSpawnFlags( SF_WEAPON_START_CONSTRAINED ) )
{
//Constrain the weapon in place
IPhysicsObject *pReferenceObject, *pAttachedObject;
pReferenceObject = g_PhysWorldObject;
pAttachedObject = VPhysicsGetObject();
if ( pReferenceObject && pAttachedObject )
{
constraint_fixedparams_t fixed;
fixed.Defaults();
fixed.InitWithCurrentObjectState( pReferenceObject, pAttachedObject );
fixed.constraint.forceLimit = lbs2kg( 10000 );
fixed.constraint.torqueLimit = lbs2kg( 10000 );
IPhysicsConstraint *pConstraint = GetConstraint();
pConstraint = physenv->CreateFixedConstraint( pReferenceObject, pAttachedObject, NULL, fixed );
pConstraint->SetGameData( (void *) this );
}
}
#endif //CLIENT_DLL
}
}
SetPickupTouch();
SetThink( &CBaseCombatWeapon::FallThink );
SetNextThink( gpGlobals->curtime + 0.1f );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: For create nodes in wc edit mode
// Input :
// Output :
//-----------------------------------------------------------------------------
void NWCEdit::CreateAINode( CBasePlayer *pPlayer )
{
// -------------------------------------------------------------
// Check that WC is running with the right map version
// -------------------------------------------------------------
if ( !IsWCVersionValid() || !pPlayer )
return;
pPlayer->AddSolidFlags( FSOLID_NOT_SOLID );
int hullType = g_pAINetworkManager->GetEditOps()->m_iHullDrawNum;
// -----------------------------------
// Get position of node to create
// -----------------------------------
Vector vNewNodePos = vec3_origin;
bool bPositionValid = false;
if (g_pAINetworkManager->GetEditOps()->m_bAirEditMode)
{
vNewNodePos = NWCEdit::AirNodePlacementPosition();
// Make sure we can see the node
trace_t tr;
UTIL_TraceLine(pPlayer->EyePosition(), vNewNodePos, MASK_NPCSOLID_BRUSHONLY, pPlayer, COLLISION_GROUP_NONE, &tr);
if (tr.fraction == 1.0)
{
bPositionValid = true;
}
}
else
{
// Place node by where the player is looking
Vector forward;
pPlayer->EyeVectors( &forward );
Vector startTrace = pPlayer->EyePosition();
Vector endTrace = pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH;
trace_t tr;
UTIL_TraceLine(startTrace,endTrace,MASK_NPCSOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0)
{
// Raise the end position up off the floor, place the node and drop him down
tr.endpos.z += 48;
vNewNodePos = tr.endpos;
bPositionValid = true;
}
}
// -------------------------------------------------------------------------------
// Now check that this is a valid location for the new node bu using test hull
// -------------------------------------------------------------------------------
if (bPositionValid)
{
CBaseEntity *testHull = (CBaseEntity*)CAI_TestHull::GetTestHull();
// Set the size of the test hull
UTIL_SetSize(testHull, NAI_Hull::Mins(hullType), NAI_Hull::Maxs(hullType));
// Set origin of test hull
testHull->SetLocalOrigin( vNewNodePos );
// -----------------------------------------------------------------------
// If a ground node, drop to floor and make sure can stand at test postion
// -----------------------------------------------------------------------
if (!g_pAINetworkManager->GetEditOps()->m_bAirEditMode)
{
UTIL_DropToFloor( testHull, MASK_NPCSOLID );
vNewNodePos = testHull->GetAbsOrigin();
CTraceFilterSimple traceFilter( testHull, COLLISION_GROUP_NONE );
if (!UTIL_CheckBottom(testHull, &traceFilter, sv_stepsize.GetFloat()))
{
CAI_TestHull::ReturnTestHull();
bPositionValid = false;
goto DoneCreate;
}
}
// -----------------------------------------------------------------------
// Make sure hull fits at location by seeing if it can move up a fraction
// -----------------------------------------------------------------------
Vector vUpBit = testHull->GetAbsOrigin();
vUpBit.z += 1;
trace_t tr;
UTIL_TraceHull( testHull->GetAbsOrigin(), vUpBit, NAI_Hull::Mins(hullType),
NAI_Hull::Maxs(hullType), MASK_NPCSOLID, testHull, COLLISION_GROUP_NONE, &tr );
if (tr.startsolid || tr.fraction != 1.0)
{
CAI_TestHull::ReturnTestHull();
bPositionValid = false;
goto DoneCreate;
}
// <<TEMP>> Round position till DS fixed WC bug
testHull->SetLocalOrigin( Vector( floor(testHull->GetAbsOrigin().x),
floor(testHull->GetAbsOrigin().y ), floor(testHull->GetAbsOrigin().z) ) );
// ---------------------------------------
// Send new node to WC
// ---------------------------------------
int status;
if (g_pAINetworkManager->GetEditOps()->m_bAirEditMode)
{
status = Editor_CreateNode("info_node_air", g_pAINetworkManager->GetEditOps()->m_nNextWCIndex, testHull->GetLocalOrigin().x, testHull->GetLocalOrigin().y, testHull->GetLocalOrigin().z, false);
}
else
{
// Create slightly higher in WC so it can be dropped when its loaded again
Vector origin = testHull->GetLocalOrigin();
origin.z += 24.0;
testHull->SetLocalOrigin( origin );
status = Editor_CreateNode("info_node", g_pAINetworkManager->GetEditOps()->m_nNextWCIndex, testHull->GetLocalOrigin().x, testHull->GetLocalOrigin().y, testHull->GetLocalOrigin().z, false);
}
if (status == Editor_BadCommand)
{
Msg( "Worldcraft failed on creation...\n" );
CAI_TestHull::ReturnTestHull();
}
else if (status == Editor_OK)
{
// -----------------------
// Create a new ai node
// -----------------------
CNodeEnt *pNodeEnt;
if (g_pAINetworkManager->GetEditOps()->m_bAirEditMode)
{
pNodeEnt = (CNodeEnt*)CreateEntityByName("info_node_air");
}
else
{
pNodeEnt = (CNodeEnt*)CreateEntityByName("info_node");
}
// Note this is a new entity being created as part of wc editing
pNodeEnt->SetLocalOrigin( testHull->GetLocalOrigin() );
CAI_TestHull::ReturnTestHull();
pNodeEnt->m_NodeData.nWCNodeID = g_pAINetworkManager->GetEditOps()->m_nNextWCIndex;
pNodeEnt->m_debugOverlays |= OVERLAY_WC_CHANGE_ENTITY;
pNodeEnt->Spawn();
}
}
DoneCreate:
// ----------------------------------------------------------
// Flash a red box as a warning that the hull won't fit here
// ----------------------------------------------------------
if (!bPositionValid)
{
NDebugOverlay::Box(vNewNodePos, NAI_Hull::Mins(hullType), NAI_Hull::Maxs(hullType), 255,0,0,0,0.1);
}
// Restore player collidability
pPlayer->SetSolid( SOLID_BBOX );
}
//=========================================================
// Crea un hijo en la ubicación especificada.
//=========================================================
bool CDirector_Manager::AddChild(const Vector &vecPosition, int flag)
{
// No se ha podido acceder al Director.
if ( !Director() )
return false;
// No es posible crear un hijo aquí.
if ( !CanMake(vecPosition) )
return false;
// Creamos un hijo de la lista.
const char *pChildName = GetChildClass();
CAI_BaseNPC *pChild = (CAI_BaseNPC *)CreateEntityByName(pChildName);
QAngle angles = RandomAngle(0, 360);
angles.x = 0.0;
angles.z = 0.0;
pChild->SetAbsAngles(angles);
// Establecemos la ubicación de creación.
pChild->SetAbsOrigin(vecPosition);
// Debe caer al suelo y desaparecer.
pChild->AddSpawnFlags(SF_NPC_FALL_TO_GROUND);
pChild->AddSpawnFlags(SF_NPC_FADE_CORPSE);
UTIL_DropToFloor(pChild, MASK_SOLID);
ConVarRef director_debug("director_debug");
DispatchSpawn(pChild);
pChild->SetOwnerEntity(Director());
DispatchActivate(pChild);
// ¡¡NO CAMBIAR!!
pChild->SetName(MAKE_STRING(CHILD_NAME));
// Sin colisiones.
if ( flag == SPAWN_NO_COLLISION || flag == SPAWN_NO_COLLISION_AND_POWERFUL )
{
pChild->SetCollisionGroup(COLLISION_GROUP_SPECIAL_NPC);
Vector vecOriginRadius;
if ( Director()->Status == PANIC && RandomInt(0, 4) == 2 )
pChild->SetCollisionGroup(COLLISION_GROUP_NPC);
// Intentamos crearlo en un radio de 100
if ( CAI_BaseNPC::FindSpotForNPCInRadius(&vecOriginRadius, vecPosition, pChild, 150, false) )
{
// Evitamos que se mueva por debajo del suelo.
vecOriginRadius.z = vecPosition.z;
// Movemos hacia esta ubicación.
pChild->SetAbsOrigin(vecOriginRadius);
// Marcamos al nodo afortunado. (Naranja)
if ( director_debug.GetBool() )
NDebugOverlay::Box(vecOriginRadius, -Vector(10, 10, 10), Vector(10, 10, 10), 255, 128, 0, 10, 20.0f);
}
}
// Poderoso.
if ( flag == SPAWN_POWERFUL || flag == SPAWN_NO_COLLISION_AND_POWERFUL )
{
int moreHealth = 3;
// Normal: 5 más de salud.
if ( InGameRules()->IsSkillLevel(SKILL_MEDIUM) )
moreHealth = 5;
// Dificil: 8 más de salud.
if ( InGameRules()->IsSkillLevel(SKILL_HARD) )
moreHealth = 8;
// Más rápido.
pChild->SetAddAccel(40);
// Establecemos la nueva salud.
pChild->SetMaxHealth(pChild->GetMaxHealth() + moreHealth);
pChild->SetHealth(pChild->GetMaxHealth());
// Seleccionamos al jugador más cercano.
float flDistance = 0.0f;
CIN_Player *pPlayer = UTIL_GetNearestInPlayer(pChild->GetAbsOrigin(), flDistance);
if ( pPlayer )
{
// Le decimos que su nuevo enemigo es el jugador y le damos la ubicación de este.
pChild->SetEnemy(pPlayer);
pChild->UpdateEnemyMemory(pPlayer, pPlayer->GetAbsOrigin());
}
}
// Al parecer se atoro en una pared.
if ( !PostSpawn(pChild) )
{
// Marcamos al nodo desafortunado. (Negro)
if ( director_debug.GetBool() )
NDebugOverlay::Box(vecPosition, -Vector(10, 10, 10), Vector(10, 10, 10), 0, 0, 0, 10, 3.0f);
return false;
}
// Marcamos al nodo afortunado. (Rojo)
if ( director_debug.GetBool() )
NDebugOverlay::Box(vecPosition, -Vector(10, 10, 10), Vector(10, 10, 10), 223, 1, 1, 10, 3.0f);
DevMsg("[MANAGER] Se ha creado <%s> (faltan %i) \r\n", pChildName, Director()->SpawnQueue);
++Director()->ChildsSpawned;
return true;
}