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

void CAnimatedCharacter::SetBlendWeightParam(const EMotionParamID motionParamID, const float value, const uint8 targetFlags/* = eBWPT_All*/){	if (motionParamID >= eMotionParamID_BlendWeight && motionParamID <= eMotionParamID_BlendWeight_Last)	{ //only allowed on the generic blend weights params		IEntity* pEntity = GetEntity();		CRY_ASSERT(pEntity);		if (targetFlags & eBWPT_FirstPersonSkeleton)		{			if (ICharacterInstance* pCharacterInstance = pEntity->GetCharacter(0))			{				if (ISkeletonAnim* pSkeletonAnim = pCharacterInstance->GetISkeletonAnim())				{					pSkeletonAnim->SetDesiredMotionParam(motionParamID, value, 0.0f);				}			}		}		if (targetFlags & eBWPT_ShadowSkeleton)		{			if (m_hasShadowCharacter)			{				if (ICharacterInstance* pShadowCharacter = pEntity->GetCharacter(m_shadowCharacterSlot))				{					if (ISkeletonAnim* pShadowSkeletonAnim = pShadowCharacter->GetISkeletonAnim())					{						pShadowSkeletonAnim->SetDesiredMotionParam(motionParamID, value, 0.0f);					}				}			}		}	} 	else	{		CryLogAlways("[CryAnimation] ERROR: motionParam that was sent: %d is not within allowed range of blendweights %d to %d", motionParamID, eMotionParamID_BlendWeight, eMotionParamID_BlendWeight_Last);	}}

void CHeavyMountedWeapon::Update( SEntityUpdateContext& ctx, int slot ){	BaseClass::Update(ctx, slot);		if (m_rotatingSoundID!=INVALID_SOUNDID)	{		if (m_RotationSoundTimeOut>0)		{			m_RotationSoundTimeOut -= ctx.fFrameTime;			RequireUpdate( eIUS_General );		}		else		{			StopSound(m_rotatingSoundID);			m_rotatingSoundID = INVALID_SOUNDID;		}	}	// Helper for editor placing	if (gEnv->IsEditing())	{		// If host id is not 0, it means it is mounted to a vehicle, so don't render the helper in that case		if (!GetHostId())		{			IRenderAuxGeom* pRenderAux = gEnv->pRenderer->GetIRenderAuxGeom();			const Matrix34& weaponTM = GetEntity()->GetWorldTM();			const Vec3 point1 = weaponTM.GetTranslation();			const Vec3 point2 = point1 - (m_sharedparams->pMountParams->ground_distance * weaponTM.GetColumn2());			const Vec3 point3 = point2 - (m_sharedparams->pMountParams->body_distance * weaponTM.GetColumn1());			pRenderAux->DrawLine(point1, ColorB(0, 192, 0), point2, ColorB(0, 192, 0), 3.0f);			pRenderAux->DrawLine(point2, ColorB(0, 192, 0), point3, ColorB(0, 192, 0), 3.0f);			pRenderAux->DrawSphere(point3, 0.15f, ColorB(192, 0, 0));			RequireUpdate(eIUS_General);		}	}}

//-----------------------------------------------------------------------void CVehiclePartLight::UpdateLight(const float frameTime){   if (m_slot == -1)    return;	// move to vehicle event change view?  if (m_diffuseMult[0] != m_diffuseMult[1])  {    SEntitySlotInfo info;    if (m_pVehicle->GetEntity()->GetSlotInfo(m_slot, info) && info.pLight)    {      CDLight& light = info.pLight->GetLightProperties();          IActor* pActor = CCryAction::GetCryAction()->GetClientActor();      bool localPlayer = (pActor != NULL) && (pActor->GetLinkedVehicle() == m_pVehicle);			IVehicleSeat* pSeat = pActor ? m_pVehicle->GetSeatForPassenger(pActor->GetEntityId()) : NULL;			IVehicleView* pView = pSeat? pSeat->GetView(pSeat->GetCurrentView()) : NULL;			bool isThirdPersonView = pView? pView->IsThirdPerson() : true;      if (localPlayer && !isThirdPersonView)				light.SetLightColor(ColorF(m_diffuseCol * m_diffuseMult[0], 1.f));      else				light.SetLightColor(ColorF(m_diffuseCol * m_diffuseMult[1], 1.f));        }  }    if (m_pHelper)  {     const static Matrix33 rot(Matrix33::CreateRotationXYZ(Ang3(0.f, 0.f, DEG2RAD(90.f))));        Matrix34 helperTM;		m_pHelper->GetVehicleTM(helperTM);    Matrix34 localTM = Matrix33(helperTM) * rot;    localTM.SetTranslation(helperTM.GetTranslation());    GetEntity()->SetSlotLocalTM(m_slot, localTM);    }}

//----------------------------------------------------void CRocketLauncher::ActivateTPLaser(bool activate){	if(activate)	{		DrawSlot( eIGS_Aux1,true);		ActivateLaserDot(true,false);		m_laserTPOn = true;				//Force first update		m_lastUpdate = 0.0f;		m_smoothLaserLength = -1.0f;		UpdateTPLaser(0.0f);		RequireUpdate(eIUS_General);	}	else	{		DrawSlot( eIGS_Aux1,false);		GetEntity()->SetSlotLocalTM( eIGS_Aux1,Matrix34::CreateIdentity());		ActivateLaserDot(false,false);		m_laserTPOn = false;	}}

//------------------------------------------bool CC4Projectile::Init(IGameObject *pGameObject){	bool ok = CProjectile::Init(pGameObject);	// C4 should always be saved (unlike other projectiles)	IEntity* pEntity = GetEntity();	pEntity->SetFlags(pEntity->GetFlags() & ~ENTITY_FLAG_NO_SAVE);	if(!gEnv->bServer)	{		CreateLight();	}	if(gEnv->bMultiplayer)	{		CGameRules *pGameRules = g_pGame->GetGameRules();		pGameRules->RegisterTeamChangedListener(this);		pGameRules->RegisterClientConnectionListener(this);	}	return ok;}

void CMonoEntityExtension::FullSerialize(TSerialize ser){	IEntity *pEntity = GetEntity();	ser.BeginGroup("Properties");	auto pPropertyHandler = static_cast<CEntityPropertyHandler *>(pEntity->GetClass()->GetPropertyHandler());	for(int i = 0; i < pPropertyHandler->GetPropertyCount(); i++)	{		if(ser.IsWriting())		{			IEntityPropertyHandler::SPropertyInfo propertyInfo;			pPropertyHandler->GetPropertyInfo(i, propertyInfo);			ser.Value(propertyInfo.name, pPropertyHandler->GetProperty(pEntity, i));		}		else		{			IEntityPropertyHandler::SPropertyInfo propertyInfo;			pPropertyHandler->GetPropertyInfo(i, propertyInfo);			char *propertyValue = nullptr;			ser.ValueChar(propertyInfo.name, propertyValue, 0);			pPropertyHandler->SetProperty(pEntity, i, propertyValue);		}	}	ser.EndGroup();	ser.BeginGroup("ManagedEntity");	IMonoArray *pArgs = CreateMonoArray(1);	pArgs->InsertNativePointer(&ser);	m_pScript->GetClass()->InvokeArray(m_pScript->GetManagedObject(), "InternalFullSerialize", pArgs);	pArgs->Release();	ser.EndGroup();}

void CFlyer::SetActorMovement(SMovementRequestParams& movementRequestParams){	SMovementState state;	GetMovementController()->GetMovementState(state);	if (movementRequestParams.vMoveDir.IsZero())	{		Vec3 vDesiredDirection = movementRequestParams.vLookTargetPos.IsZero()			? GetEntity()->GetWorldRotation() * FORWARD_DIRECTION			: (movementRequestParams.vLookTargetPos - state.eyePosition).GetNormalizedSafe();		SetDesiredDirection(vDesiredDirection);		SetDesiredVelocity(Vec3Constants<float>::fVec3_Zero);	}	else	{		Vec3 vDesiredDirection = movementRequestParams.vLookTargetPos.IsZero()			? movementRequestParams.vMoveDir.GetNormalizedSafe()			: (movementRequestParams.vLookTargetPos - state.eyePosition).GetNormalizedSafe();		SetDesiredDirection(vDesiredDirection);		SetDesiredVelocity(movementRequestParams.vMoveDir * movementRequestParams.fDesiredSpeed);	}}

void CBoundingContainer::ProcessEvent( SEntityEvent& entityEvent ){	switch(entityEvent.event)	{	case ENTITY_EVENT_RESET:		{			const bool bEnteringGameMode = ( entityEvent.nParam[ 0 ] == 1 );			Reset( bEnteringGameMode );		}		break;	case ENTITY_EVENT_START_LEVEL: // Need to wait till all entities are loaded since other entities can be inside		{			bool bHideContainedItemsOnStart = false;			EntityScripts::GetEntityProperty(GetEntity(), "bHideContainedItemsOnStart", bHideContainedItemsOnStart);			if (bHideContainedItemsOnStart && !gEnv->IsEditor())			{				HideContainedItems();			}		}		break;	}}

RodinBTNode::ETickStatus RodinBTNodePlayActions::Tick(float DeltaTime) {  Unused(DeltaTime);  WBEntity* const pEntity = GetEntity();  WBEvent BTNodePlayActionsEvent;  STATIC_HASHED_STRING(BTNodePlayActionsEvent);  BTNodePlayActionsEvent.SetEventName(sBTNodePlayActionsEvent);  pEntity->AddContextToEvent(BTNodePlayActionsEvent);  const uint NumActions = m_Actions.Size();  for (uint ActionIndex = 0; ActionIndex < NumActions; ++ActionIndex) {    WBAction* const pAction = m_Actions[ActionIndex];    ASSERT(pAction);    WBActionStack::Push(BTNodePlayActionsEvent);    pAction->Execute();    WBActionStack::Pop();  }  return ETS_Success;}

void CComponentVida::Decrease(float _fAmount){  if(m_fVida > 0.0f)  {    m_fTimeSinceHit = 0.0f;    if(_fAmount < 0.0f)      _fAmount *= -1;    m_fVida -= _fAmount;    if(m_fVida <= 0.f)    {      m_fVida = 0.0f;      SEvent l_morir;      l_morir.Msg = SEvent::MORIR;      l_morir.Receiver = l_morir.Sender = GetEntity()->GetGUID();            CORE->GetEntityManager()->SendEvent(l_morir);    }  }}

bool Bot::IsFriendInLineOfFire (float distance){   // bot can't hurt teammates, if friendly fire is not enabled...   if (!engine->IsFriendlyFireOn ())      return false;   MakeVectors (pev->v_angle);   TraceResult tr;   TraceLine (EyePosition (), EyePosition () + pev->v_angle.Normalize () * distance, false, false, GetEntity (), &tr);   // check if we hit something   if (!FNullEnt (tr.pHit))   {      int playerIndex = ENTINDEX (tr.pHit) - 1;      // check valid range      if (playerIndex >= 0 && playerIndex < engine->GetMaxClients () && g_clients[playerIndex].team == GetTeam (GetEntity ()) && (g_clients[playerIndex].flags & CFLAG_ALIVE))         return true;   }   // search the world for players   for (int i = 0; i < engine->GetMaxClients (); i++)   {      if (!(g_clients[i].flags & CFLAG_USED) || !(g_clients[i].flags & CFLAG_ALIVE) || g_clients[i].team != GetTeam (GetEntity ()) || g_clients[i].ent == GetEntity ())         continue;      edict_t *ent = g_clients[i].ent;      float friendDistance = (GetEntityOrigin (ent) - pev->origin).GetLength ();      float squareDistance = sqrtf (1089.0f + (friendDistance * friendDistance));      if ((GetShootingConeDeviation (GetEntity (), &GetEntityOrigin (ent))) > 		  ((friendDistance * friendDistance) / (squareDistance * squareDistance)) && 		  friendDistance <= distance)         return true;   }   return false;}

bool Bot::IsGroupOfEnemies (Vector location, int numEnemies, int radius){   int numPlayers = 0;   // search the world for enemy players...   for (int i = 0; i < engine->GetMaxClients (); i++)   {      if (!(g_clients[i].flags & CFLAG_USED) || !(g_clients[i].flags & CFLAG_ALIVE) || g_clients[i].ent == GetEntity ())         continue;      if ((GetEntityOrigin (g_clients[i].ent) - location).GetLength () < radius)      {         // don't target our teammates...         if (g_clients[i].team == GetTeam (GetEntity ()))            return false;         if (numPlayers++ > numEnemies)            return true;      }   }   return false;}

//------------------------------------------------------------------------void CVehiclePartEntity::UpdateEntity(){	if(IEntity *pEntity = GetPartEntity())	{		Matrix34	worldTM;		if(m_pHelper)		{			m_pHelper->GetWorldTM(worldTM);		}		else if(IVehiclePart *pParent = GetParent())		{			worldTM	= pParent->GetWorldTM();		}		else		{			worldTM	= GetEntity()->GetWorldTM();		}		pEntity->SetWorldTM(worldTM);	}}

//================================================================================// Update hitbox positions and visibility// This function can be very expensive, it should only be called for the active enemy.//================================================================================void CEntityMemory::UpdateHitboxAndVisibility(){	VPROF_BUDGET("CEntityMemory::UpdateHitboxAndVisibility", VPROF_BUDGETGROUP_BOTS_EXPENSIVE);	// For now let's assume that we do not know Hitbox and therefore we have no vision	UpdateVisibility(false);	m_Hitbox.Reset();	m_VisibleHitbox.Reset();	// We obtain the positions of the Hitbox	Utils::GetHitboxPositions(GetEntity(), m_Hitbox);	if (!m_Hitbox.IsValid())		return;	{		VPROF_BUDGET("UpdateVisibility", VPROF_BUDGETGROUP_BOTS_EXPENSIVE);		// Now let's check if we can see any of them		if (m_pBot->GetDecision()->IsAbleToSee(m_Hitbox.head)) {			m_VisibleHitbox.head = m_Hitbox.head;			UpdateVisibility(true);		}		if (m_pBot->GetDecision()->IsAbleToSee(m_Hitbox.chest)) {			m_VisibleHitbox.chest = m_Hitbox.chest;			UpdateVisibility(true);		}		if (m_pBot->GetDecision()->IsAbleToSee(m_Hitbox.feet)) {			m_VisibleHitbox.feet = m_Hitbox.feet;			UpdateVisibility(true);		}	}	// We update the ideal position	GetVisibleHitboxPosition(m_vecIdealPosition, m_pBot->GetProfile()->GetFavoriteHitbox());}

void CBoundingContainer::HideContainedItems(){	IEntity* pEntity = GetEntity();	if (pEntity)	{		// Proximity query all entities in area		AABB aabbBounds(m_vBoundingMin, m_vBoundingMax);		OBB	obbBounds;		Matrix34	worldTM = pEntity->GetWorldTM();		obbBounds.SetOBBfromAABB(Matrix33(worldTM), aabbBounds);		aabbBounds.Reset();		aabbBounds.SetAABBfromOBB(pEntity->GetWorldPos(), obbBounds);		SEntityProximityQuery query;		query.box = aabbBounds;		gEnv->pEntitySystem->QueryProximity(query);		const int iQueryCount = query.nCount;		for (int i = 0; i < iQueryCount; ++i)		{			IEntity* pQueryEntity = query.pEntities[i];			if (pQueryEntity)			{				const EntityId queryEntityId = pQueryEntity->GetId();								if (!stl::find(m_hiddenEntities, queryEntityId)) // Only if not already hidden				{					// Make sure entity type should be hidden and entity pos is also inside, not just an intersection					if (ShouldHide(queryEntityId, pQueryEntity) && aabbBounds.IsContainPoint(pQueryEntity->GetWorldPos()))					{						pQueryEntity->Hide(true);						m_hiddenEntities.push_back(pQueryEntity->GetId());					}				}			}		}	}}

void CAICorpse::HandleEvent( const SGameObjectEvent& gameObjectEvent ){	if(gameObjectEvent.event == eCGE_ItemTakenFromCorpse)	{		assert(gameObjectEvent.param != NULL);		bool matchFound = false;		const EntityId itemId = *static_cast<const EntityId*>(gameObjectEvent.param);		for (uint32 i = 0; i < m_attachedItemsInfo.size(); ++i)		{			if(m_attachedItemsInfo[i].id == itemId)			{				ICharacterInstance* pCharacter = GetEntity()->GetCharacter(0);				if(pCharacter != NULL)				{					IAttachment* pAttachment = pCharacter->GetIAttachmentManager()->GetInterfaceByName( m_attachedItemsInfo[i].attachmentName.c_str() );					if(pAttachment != NULL)					{						pAttachment->ClearBinding();					}				}				m_attachedItemsInfo.removeAt(i);				matchFound = true;				break;			}		}		if(matchFound)		{			if(m_attachedItemsInfo.empty())			{				m_priority = 0; //Lower the priority once all attached items have been removed			}		}	}}

        //-----------------------------------------------------------        /// The image from the texture atlas will have potentially        /// been cropped by the tool. This will affect the sprites        /// position within the uncropped image and we need to        /// account for that when positioning the corners        //-----------------------------------------------------------		void SpriteComponent::UpdateVertexPositions()        {            Core::Vector2 frameCenter;            Core::Vector2 frameSize;            if(m_textureAtlas != nullptr && m_hashedTextureAtlasId > 0)            {                CalcFrameCentreAndSize(frameCenter, frameSize);            }            else if(mpMaterial != nullptr && mpMaterial->GetTexture() != nullptr)            {                auto texture = mpMaterial->GetTexture().get();                frameSize = m_sizePolicyDelegate(m_originalSize, Core::Vector2((f32)texture->GetWidth(), (f32)texture->GetHeight()));            }                        const Core::Matrix4& worldTransform = GetEntity()->GetTransform().GetWorldTransform();			Core::Vector2 halfFrameSize(frameSize.x * 0.5f, frameSize.y * 0.5f);			Core::Vector2 alignedPosition = -GetAnchorPoint(m_originAlignment, halfFrameSize);            Core::Vector4 vertexCentre(alignedPosition.x + frameCenter.x, alignedPosition.y + frameCenter.y, 0.0f, 1.0f);                        //TL            Core::Vector4 vertexOffset(-halfFrameSize.x, halfFrameSize.y, 0.0f, 0.0f);			m_spriteData.sVerts[(u32)SpriteBatch::Verts::k_topLeft].vPos = (vertexCentre + vertexOffset) * worldTransform;                        //TR            vertexOffset.x = halfFrameSize.x;            vertexOffset.y = halfFrameSize.y;			m_spriteData.sVerts[(u32)SpriteBatch::Verts::k_topRight].vPos = (vertexCentre + vertexOffset) * worldTransform;                        //BL            vertexOffset.x = -halfFrameSize.x;            vertexOffset.y = -halfFrameSize.y;			m_spriteData.sVerts[(u32)SpriteBatch::Verts::k_bottomLeft].vPos = (vertexCentre + vertexOffset) * worldTransform;                        //BR            vertexOffset.x = halfFrameSize.x;            vertexOffset.y = -halfFrameSize.y;			m_spriteData.sVerts[(u32)SpriteBatch::Verts::k_bottomRight].vPos = (vertexCentre + vertexOffset) * worldTransform;		}

//------------------------------------------------------------------------void CProjectile::SetParams(EntityId ownerId, EntityId hostId, EntityId weaponId, int damage, int hitTypeId, float damageDrop /*= 0.0f*/, float damageDropMinR /*=0.0f*/){	m_ownerId = ownerId;	m_weaponId = weaponId;	m_hostId = hostId;	m_damage = damage;  m_hitTypeId = hitTypeId;	m_damageDropPerMeter = damageDrop;	m_damageDropMinDisSqr = damageDropMinR*damageDropMinR;	if (m_hostId || m_ownerId)	{		IEntity* pSelfEntity = GetEntity();		if (pSelfEntity)			pSelfEntity->AddEntityLink("Shooter", m_ownerId);		IEntity *pEntity = gEnv->pEntitySystem->GetEntity(m_hostId?m_hostId:m_ownerId);		if (pEntity)		{			if (pSelfEntity)			{				//need to set AI species to the shooter - not to be scared of it's own rockets 				IAIObject* projectileAI = pSelfEntity->GetAI();				IAIObject* shooterAI = pEntity->GetAI();				if (projectileAI && shooterAI)					projectileAI->SetFactionID(shooterAI->GetFactionID());			}			if (m_pPhysicalEntity && m_pPhysicalEntity->GetType()==PE_PARTICLE)			{				pe_params_particle pparams;				pparams.pColliderToIgnore = pEntity->GetPhysics();				m_pPhysicalEntity->SetParams(&pparams);			}		}	}}

void CFlyer::PrePhysicsUpdate(){	if(m_stats.isRagDoll)		return;	if(GetHealth() <= 0.f)		return;	IEntity *pEntity = GetEntity();	if(pEntity->IsHidden())		return;	if(IPhysicalEntity *pPhysicalEntity = pEntity->GetPhysics())	{		pe_player_dynamics player_dynamics;		player_dynamics.gravity.zero();		pPhysicalEntity->SetParams(&player_dynamics);	}	float frameTime = gEnv->pTimer->GetFrameTime();	if(m_pMovementController)	{		SActorFrameMovementParams params;		m_pMovementController->Update(frameTime, params);	}	if(m_linkStats.CanMove() && m_linkStats.CanRotate())	{		ProcessMovement(frameTime);		if(m_pAnimatedCharacter)		{			m_pAnimatedCharacter->AddMovement(m_moveRequest);		}	}}

int CScriptBind_Boids::SetFlockParams(IFunctionHandler *pH,SmartScriptTable entity,SmartScriptTable paramTable){	CFlock *flock = GetFlock(entity);	if (!flock)		return pH->EndFunction();	string currModel = flock->GetModelName();	int currCount = flock->GetBoidsCount();	SBoidContext bc;	flock->GetBoidSettings(bc);	SBoidsCreateContext ctx;	if (ReadParamsTable( paramTable,bc,ctx ))	{		flock->SetBoidSettings( bc );		string model = "";		if (!ctx.models.empty())			model  = ctx.models[0];		if ((!model.empty()  && stricmp(model.c_str(),currModel.c_str()) == 0) ||				(ctx.boidsCount > 0 && ctx.boidsCount != currCount))		{			flock->CreateBoids( ctx );		}	}	IEntity *pEntity = GetEntity(entity);	if (pEntity)	{		CBoidsProxy *pBoidsProxy = (CBoidsProxy*)pEntity->GetProxy(ENTITY_PROXY_BOIDS);		if (pBoidsProxy)		{			// Update 			pBoidsProxy->SetFlock(flock);		}	}	return pH->EndFunction();}

int XENTITYS::Ref2Entity( const char* estr, char* str, int strlen ){	char* pes = (char*)estr;	char* ps = str;	char* ps_end = ps+strlen;	while( pes && *pes && ps < ps_end )	{		XENTITY *ent = GetEntity( pes );		if( ent )		{			// copy entity meanning char			*ps = ent->entity;			pes += ent->ref_len;		}		else			*ps = *pes++;	// default character copy		ps++;	}	*ps = '/0';		// total copied characters	return ps-str;	}

int _tagXMLEntitys::Ref2Entity( LPCTSTR estr, LPTSTR str, int strlen ){	LPTSTR pes = (LPTSTR)estr;	LPTSTR ps = str;	LPTSTR ps_end = ps+strlen;	while( pes && *pes && ps < ps_end )	{		LPXENTITY ent = GetEntity( pes );		if( ent )		{			// copy entity meanning char			*ps = ent->entity;			pes += ent->ref_len;		}		else			*ps = *pes++;	// default character copy		ps++;	}	*ps = '/0';		// total copied characters	return ps-str;	}

//------------------------------------------------------------------------void CItem::StopLayer(const ItemString& layerName, int flags, bool record){	TLayerMap::iterator it = m_sharedparams->layers.find(CONST_TEMPITEM_STRING(layerName));	if (it == m_sharedparams->layers.end())		return;	for (int i=0; i<eIGS_Last; i++)	{		if (!(flags&1<<i))			continue;		ICharacterInstance *pCharacter = GetEntity()->GetCharacter(i);		if (pCharacter)			pCharacter->GetISkeletonAnim()->StopAnimationInLayer(it->second.id[i],0.0f);	}	if (record)	{		TActiveLayerMap::iterator ait = m_activelayers.find(CONST_TEMPITEM_STRING(layerName));		if (ait != m_activelayers.end())			m_activelayers.erase(ait);	}}

void CHeavyMountedWeapon::OnReset(){	BaseClass::OnReset();	m_rippedOff = m_rippingOff = false;	m_stats.mounted = true;	m_rotatingSoundID = INVALID_SOUNDID;	m_lastUsedFrame = -1;	Physicalize(false, false);	RequireUpdate(eIUS_General);	if (m_linkedParentId != 0)	{		IEntity* pLinkedParent = gEnv->pEntitySystem->GetEntity(m_linkedParentId);		if (pLinkedParent)		{			pLinkedParent->AttachChild(GetEntity());		}		m_linkedParentId = 0;	}}

void CLivingEntitySample::StartAnimationForCurrentAnimationState(){	IEntity* pEntity = GetEntity();	const int slot = 0;	ICharacterInstance* pCharacterInstance = pEntity->GetCharacter( slot );	if ( pCharacterInstance == NULL )	{		return;	}	ISkeletonAnim* pSkeletonAnim = pCharacterInstance->GetISkeletonAnim();	if ( pSkeletonAnim == NULL )	{		return;	}	CryCharAnimationParams animationParams;	animationParams.m_nFlags |= CA_LOOP_ANIMATION;	animationParams.m_nLayerID = 0;	animationParams.m_fTransTime = 0.3f;	const char* animationName = IDLE_ANIMATION_NAME;	switch ( m_animationState )	{	case None:	case Idle:		animationName = IDLE_ANIMATION_NAME;		break;	case Walk:		animationName = WALK_ANIMATION_NAME;		break;	}	pSkeletonAnim->StartAnimation( animationName, animationParams );}

void CJaw::PickUp(EntityId pickerId, bool sound, bool select, bool keepHistory, const char* setup){	for (TAmmoVector::iterator it = m_bonusammo.begin(); it != m_bonusammo.end(); ++it)	{		SWeaponAmmo& currentBonusAmmo = *it;		currentBonusAmmo.count = 0;	}	IItemSystem* pItemSystem = gEnv->pGame->GetIGameFramework()->GetIItemSystem();	IActor* pPicketActor = gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(pickerId);	IInventory* pInventory = pPicketActor->GetInventory();	bool giveExtraTube = GiveExtraTubeToInventory(pPicketActor, pItemSystem);	if (pPicketActor->IsClient())		SetAmmoCount(m_fm->GetAmmoType(), 1);	BaseClass::PickUp(pickerId,sound,select,keepHistory, setup);	if (giveExtraTube)	{		int numJaws = m_weaponsharedparams->ammoParams.extraItems;		while(numJaws-- > 0)		{			pItemSystem->GiveItem(pPicketActor, GetEntity()->GetClass()->GetName(), false, false, false);		}		m_extraTubesAdded = true;	}	if(m_auxSlotUsed)	{		DrawSlot(eIGS_ThirdPersonAux,false);		m_auxSlotUsed = false;	}	if(GetOwnerActor() && !GetOwnerActor()->IsPlayer())		m_stats.first_selection = false;}

RodinBTNode::ETickStatus RodinBTNodeEldLookAt::Tick(float DeltaTime) {  Unused(DeltaTime);  WBEntity* const pEntity = GetEntity();  WBCompRodinBlackboard* const pAIBlackboard =      GET_WBCOMP(pEntity, RodinBlackboard);  ASSERT(pAIBlackboard);  const WBEvent::EType TargetType =      pAIBlackboard->GetType(m_LookTargetBlackboardKey);  if (TargetType == WBEvent::EWBEPT_Vector) {    const Vector LookTarget =        pAIBlackboard->GetVector(m_LookTargetBlackboardKey);    WB_MAKE_EVENT(LookAt, pEntity);    WB_SET_AUTO(LookAt, Vector, LookAtLocation, LookTarget);    WB_DISPATCH_EVENT(GetEventManager(), LookAt, pEntity);    return ETS_Success;  } else if (TargetType == WBEvent::EWBEPT_Entity) {    WBEntity* const pLookTargetEntity =        pAIBlackboard->GetEntity(m_LookTargetBlackboardKey);    if (!pLookTargetEntity) {      return ETS_Fail;    }    WB_MAKE_EVENT(LookAt, pEntity);    WB_SET_AUTO(LookAt, Entity, LookAtEntity, pLookTargetEntity);    WB_DISPATCH_EVENT(GetEventManager(), LookAt, pEntity);    return ETS_Success;  }  return ETS_Fail;}

void CDoorPanel::Update( SEntityUpdateContext& ctx, int slot ){	if (m_bHasDelayedStateEvent)	{		if (m_fDelayedStateEventTimeDelay > FLT_EPSILON)		{			m_fDelayedStateEventTimeDelay -= ctx.fFrameTime;		}		else		{			m_fDelayedStateEventTimeDelay = -1.0f;			m_bHasDelayedStateEvent = false;			const EDoorPanelBehaviorState delayedState = m_delayedState;			m_delayedState = eDoorPanelBehaviorState_Invalid;			SetStateById(delayedState);		}			}	// Check visible distance	if (m_fVisibleDistanceSq > 0.0f)	{		const float fCurTime = ctx.fCurrTime;		if ((fCurTime - m_fLastVisibleDistanceCheckTime) >= GetGameConstCVar(g_flashdoorpanel_distancecheckinterval))		{			m_fLastVisibleDistanceCheckTime = fCurTime;			const Vec3& clientPos = CHUDUtils::GetClientPos();			const float fDistSqFromClientToObject = clientPos.GetSquaredDistance(GetEntity()->GetWorldPos());			const bool bVisible = fDistSqFromClientToObject <= m_fVisibleDistanceSq;			if (bVisible != m_bFlashVisible)			{				m_bFlashVisible = bVisible;				SDoorPanelVisibleEvent visibleEvent( bVisible );				StateMachineHandleEventBehavior( visibleEvent );			}		}	}}

void CMonoActor::ProcessEvent(SEntityEvent& event){	if(m_pScript == nullptr)		return;	HandleEntityEvent(event, GetEntity(), m_pScript);	switch (event.event)	{	case ENTITY_EVENT_UNHIDE:	case ENTITY_EVENT_VISIBLE:		GetGameObject()->RequestRemoteUpdate(eEA_Physics | eEA_GameClientDynamic | eEA_GameServerDynamic | eEA_GameClientStatic | eEA_GameServerStatic);		break;	case ENTITY_EVENT_START_GAME:		{			GetGameObject()->RequestRemoteUpdate(eEA_Physics | eEA_GameClientDynamic | eEA_GameServerDynamic | eEA_GameClientStatic | eEA_GameServerStatic);			if (m_pAnimatedCharacter)				m_pAnimatedCharacter->ResetState();		}		break;	case ENTITY_EVENT_RESET:		{			if (m_pAnimatedCharacter)				m_pAnimatedCharacter->ResetState();			GetGameObject()->RequestRemoteUpdate(eEA_Physics | eEA_GameClientDynamic | eEA_GameServerDynamic | eEA_GameClientStatic | eEA_GameServerStatic);		}		break;	case ENTITY_EVENT_INIT:		{			if (m_pAnimatedCharacter)				m_pAnimatedCharacter->ResetState();		}		break;  }  }