//---------------------------------------------------
void CTacBullet::SleepTargetInVehicle(EntityId shooterId, CActor* pActor)
{
IAISystem *pAISystem=gEnv->pAISystem;
if (pAISystem)
{
if(IEntity* pEntity=pActor->GetEntity())
{
if(IAIObject* pAIObj=pEntity->GetAI())
{
IAIActor* pAIActor = pAIObj->CastToIAIActor();
if(pAIActor)
{
IAISignalExtraData *pEData = pAISystem->CreateSignalExtraData();
// try to retrieve the shooter position
if (IEntity* pOwnerEntity = gEnv->pEntitySystem->GetEntity(shooterId))
pEData->point = pOwnerEntity->GetWorldPos();
else
pEData->point = pEntity->GetWorldPos();
pAIActor->SetSignal(1,"OnFallAndPlay",0,pEData);
}
}
}
}
pActor->CreateScriptEvent("sleep", 0);
if (IAnimationGraphState* animGraph = pActor->GetAnimationGraphState())
animGraph->SetInput( "Signal", "fall" );
float sleepTime = 30.0f;
if(m_pAmmoParams)
sleepTime = m_pAmmoParams->sleepTime;
pActor->SetSleepTimer(sleepTime);
}
bool CDialogActorContext::DoLookAt(IEntity *pEntity, IEntity *pLookAtEntity, bool& bReachedTarget)
{
bReachedTarget = false;
IAIObject* pAI = pEntity->GetAI();
if (pAI == 0)
return false;
IAIActor* pAIActor = pAI->CastToIAIActor();
if (!pAIActor)
{
return false;
}
if (pLookAtEntity == 0)
{
pAIActor->ResetLookAt();
bReachedTarget = true;
m_bLookAtNeedsReset = false;
}
else
{
IAIObject* pTargetAI = pLookAtEntity->GetAI();
Vec3 pos = pTargetAI ? pTargetAI->GetPos() : pLookAtEntity->GetWorldPos();
bReachedTarget = pAIActor->SetLookAtPointPos(pos, true);
m_bLookAtNeedsReset = true;
}
return true;
}
//------------------------------------------------------------------------
int CScriptBind_Actor::Fall(IFunctionHandler *pH, Vec3 hitPos)
{
CActor *pActor = GetActor(pH);
if (!pActor)
return pH->EndFunction();
// [Mikko] 11.10.2007 - Moved the check here, since it was causing too much trouble in CActor.Fall().
// The point of this filtering is to mostly mask out self-induced collision damage on friendly NPCs
// which are playing special animations.
if(!g_pGameCVars->g_enableFriendlyFallAndPlay)
{
if (IAnimatedCharacter* pAC = pActor->GetAnimatedCharacter())
{
if ((pAC->GetPhysicalColliderMode() == eColliderMode_NonPushable) ||
(pAC->GetPhysicalColliderMode() == eColliderMode_PushesPlayersOnly))
{
// Only mask for player friendly NPCs.
if (pActor->GetEntity() && pActor->GetEntity()->GetAI())
{
IAIObject* pAI = pActor->GetEntity()->GetAI();
IAIActor* pAIActor = pAI->CastToIAIActor();
if (pAIActor && pAIActor->GetParameters().m_nSpecies == 0)
{
return pH->EndFunction();
}
}
}
}
}
pActor->Fall(hitPos);
return pH->EndFunction();
}
bool CDialogActorContext::ExecuteAI(int& goalPipeID, const char* signalText, IAISignalExtraData* pExtraData, bool bRegisterAsListener)
{
IEntitySystem* pSystem = gEnv->pEntitySystem;
IEntity* pEntity = pSystem->GetEntity(m_entityID);
if (pEntity == 0)
return false;
IAIObject* pAI = pEntity->GetAI();
if (pAI == 0)
return false;
unsigned short nType=pAI->GetAIType();
if ( nType != AIOBJECT_ACTOR )
{
if ( nType == AIOBJECT_PLAYER )
{
goalPipeID = -1;
// not needed for player
// pAI->SetSignal( 10, signalText, pEntity, NULL ); // 10 means this signal must be sent (but sent[!], not set)
// even if the same signal is already present in the queue
return true;
}
// invalid AIObject type
return false;
}
IPipeUser* pPipeUser = pAI->CastToIPipeUser();
if (pPipeUser)
{
if (goalPipeID > 0)
{
pPipeUser->RemoveSubPipe(goalPipeID, true);
pPipeUser->UnRegisterGoalPipeListener( this, goalPipeID );
goalPipeID = 0;
}
}
goalPipeID = gEnv->pAISystem->AllocGoalPipeId();
if (pExtraData == 0)
pExtraData = gEnv->pAISystem->CreateSignalExtraData();
pExtraData->iValue = goalPipeID;
if (pPipeUser && bRegisterAsListener)
{
pPipeUser->RegisterGoalPipeListener( this, goalPipeID, "CDialogActorContext::ExecuteAI");
}
IAIActor* pAIActor = CastToIAIActorSafe(pAI);
if(pAIActor)
pAIActor->SetSignal( 10, signalText, pEntity, pExtraData ); // 10 means this signal must be sent (but sent[!], not set)
// even if the same signal is already present in the queue
return true;
}
void CNetPlayerInput::DoSetState(const SSerializedPlayerInput& input )
{
m_newInterpolation |= (input.position != m_curInput.position) || (input.deltaMovement != m_curInput.deltaMovement);
const bool wasSprinting = m_curInput.sprint;
m_curInput = input;
CHANGED_NETWORK_STATE(m_pPlayer, CPlayer::ASPECT_INPUT_CLIENT );
if(wasSprinting != input.sprint)
{
SInputEventData inputEventData( SInputEventData::EInputEvent_Sprint, m_pPlayer->GetEntityId(), CCryName("sprint"), input.sprint ? eAAM_OnPress : eAAM_OnRelease, 0.f );
m_pPlayer->StateMachineHandleEventMovement( SStateEventPlayerInput( &inputEventData ) );
}
// not having these set seems to stop a remote avatars rotation being reflected
m_curInput.aiming = true;
m_curInput.allowStrafing = true;
m_curInput.usinglookik = true;
IAIActor* pAIActor = CastToIAIActorSafe(m_pPlayer->GetEntity()->GetAI());
if (pAIActor)
pAIActor->GetState().bodystate=input.bodystate;
CMovementRequest moveRequest;
moveRequest.SetStance( (EStance)m_curInput.stance );
if(IsDemoPlayback())
{
Vec3 localVDir(m_pPlayer->GetViewQuatFinal().GetInverted() * m_curInput.lookDirection);
Ang3 deltaAngles(asinf(localVDir.z),0,atan2_tpl(-localVDir.x,localVDir.y));
moveRequest.AddDeltaRotation(deltaAngles*gEnv->pTimer->GetFrameTime());
}
moveRequest.SetPseudoSpeed(CalculatePseudoSpeed());
moveRequest.SetAllowStrafing(input.allowStrafing);
m_pPlayer->GetMovementController()->RequestMovement(moveRequest);
#if !defined(_RELEASE)
// debug..
if (g_pGameCVars->g_debugNetPlayerInput & 1)
{
IPersistantDebug * pPD = gEnv->pGame->GetIGameFramework()->GetIPersistantDebug();
pPD->Begin( string("net_player_input_") + m_pPlayer->GetEntity()->GetName(), true );
pPD->AddSphere( moveRequest.GetLookTarget(), 0.5f, ColorF(1,0,1,1), 1.0f );
// pPD->AddSphere( moveRequest.GetMoveTarget(), 0.5f, ColorF(1,1,0,1), 1.0f );
Vec3 wp(m_pPlayer->GetEntity()->GetWorldPos() + Vec3(0,0,2));
pPD->AddDirection( wp, 1.5f, m_curInput.deltaMovement, ColorF(1,0,0,1), 1.0f );
pPD->AddDirection( wp, 1.5f, m_curInput.lookDirection, ColorF(0,1,0,1), 1.0f );
}
#endif
}
int CAIAwarenessToPlayerHelper::GetAlertnessAffectedByVisibility(const IAIActor& aiActor, const IAIObject& playerAiObject, const bool playerIsCloaked) const
{
int alertness = aiActor.GetProxy()->GetAlertnessState();
// Clamp the alertness to orange (1) if the player is cloaked or
// if he's not currently seen by this ai actor.
if (playerIsCloaked || !aiActor.CanSee(playerAiObject.GetVisionID()))
{
alertness = std::min(alertness, 1);
}
return alertness;
}
void CAIInput::GetState( SSerializedPlayerInput& input )
{
SMovementState movementState;
m_pPlayer->GetMovementController()->GetMovementState( movementState );
Quat worldRot = m_pPlayer->GetBaseQuat();
input.stance = movementState.stance;
input.bodystate = 0;
IAIActor* pAIActor = CastToIAIActorSafe(m_pPlayer->GetEntity()->GetAI());
if (pAIActor)
{
input.bodystate=pAIActor->GetState().bodystate;
input.allowStrafing = pAIActor->GetState().allowStrafing;
}
float maxSpeed = m_pPlayer->GetStanceMaxSpeed(m_pPlayer->GetStance());
if(maxSpeed == 0.0f)
maxSpeed = 1.0f;
input.deltaMovement = movementState.movementDirection.GetNormalizedSafe()*movementState.desiredSpeed / maxSpeed;;
input.lookDirection = movementState.eyeDirection;
// PLAYERPREDICTION
input.bodyDirection = movementState.entityDirection;
// ~PLAYERPREDICTION
input.sprint = false;
input.leanl = false;
input.leanr = false;
IAnimationGraphState *pState=0;
if (m_pPlayer->GetAnimatedCharacter())
pState=m_pPlayer->GetAnimatedCharacter()->GetAnimationGraphState();
if (pState)
{
input.aiming = pState->GetInputAsFloat(m_pPlayer->m_inputAiming)!=0.0f;
input.usinglookik = pState->GetInputAsFloat(m_pPlayer->m_inputUsingLookIK)!=0.0f;
input.pseudoSpeed=pState->GetInputAsFloat(pState->GetInputId("PseudoSpeed"));
}
}
//------------------------------------------------------------------------
void CProjectile::SetParams(EntityId ownerId, EntityId hostId, EntityId weaponId, int fmId, int damage, int hitTypeId)
{
m_ownerId = ownerId;
m_weaponId = weaponId;
m_fmId = fmId;
m_hostId = hostId;
m_damage = damage;
m_hitTypeId = hitTypeId;
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
IAIActor* pAIActor = CastToIAIActorSafe(pSelfEntity->GetAI());
IAIActor* pShooterAIActor = CastToIAIActorSafe(pEntity->GetAI());
if (pAIActor && pShooterAIActor)
{
AgentParameters ap = pAIActor->GetParameters();
ap.m_nSpecies = pShooterAIActor->GetParameters().m_nSpecies;
pAIActor->SetParameters(ap);
}
}
if (m_pPhysicalEntity && m_pPhysicalEntity->GetType()==PE_PARTICLE)
{
pe_params_particle pparams;
pparams.pColliderToIgnore = pEntity->GetPhysics();
m_pPhysicalEntity->SetParams(&pparams);
}
}
}
}
//------------------------------------------------------------------------
void SSleepEffect::Activate(EntityId targetId, EntityId ownerId, EntityId weaponId, const char *effect, const char *defaultEffect)
{
CActor *pActor = (CActor *)gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(targetId);
if (pActor)
{
IAISystem *pAISystem=gEnv->pAISystem;
if (pAISystem)
{
if(IEntity* pEntity=pActor->GetEntity())
{
if(IAIObject* pAIObj=pEntity->GetAI())
{
IAISignalExtraData *pEData = pAISystem->CreateSignalExtraData(); // no leak - this will be deleted inside SendAnonymousSignal
// try to retrieve the shooter position
if (IEntity* pOwnerEntity = gEnv->pEntitySystem->GetEntity(ownerId))
pEData->point = pOwnerEntity->GetWorldPos();
else
pEData->point = pEntity->GetWorldPos();
IAIActor* pAIActor = pAIObj->CastToIAIActor();
if(pAIActor)
pAIActor->SetSignal(1,"TRANQUILIZED",0,pEData);
}
}
}
pActor->CreateScriptEvent("sleep", 0);
pActor->GetGameObject()->SetPhysicalizationProfile(eAP_Sleep);
// no dropping weapons for AI
if(pActor->IsPlayer())
pActor->DropItem(pActor->GetCurrentItemId(), 1.0f, false);
pActor->SetSleepTimer(12.5f);
}
}
//////////////////////////////////////////////////////////////////////////
// IsMountedWeaponUsableWithTarget
// A piece of game-code moved from CryAction when scriptbind_AI moved to the AI system
//////////////////////////////////////////////////////////////////////////
int CScriptBind_Game::IsMountedWeaponUsableWithTarget(IFunctionHandler *pH)
{
int paramCount = pH->GetParamCount();
if(paramCount<2)
{
GameWarning("%s: too few parameters.", __FUNCTION__);
return pH->EndFunction();
}
GET_ENTITY(1);
if(!pEntity)
{
GameWarning("%s: wrong entity id in parameter 1.", __FUNCTION__);
return pH->EndFunction();
}
IAIObject* pAI = pEntity->GetAI();
if (!pAI)
{
GameWarning("%s: Entity '%s' does not have AI.",__FUNCTION__, pEntity->GetName());
return pH->EndFunction();
}
EntityId itemEntityId;
ScriptHandle hdl2;
if(!pH->GetParam(2,hdl2))
{
GameWarning("%s: wrong parameter 2 format.", __FUNCTION__);
return pH->EndFunction();
}
itemEntityId = (EntityId)hdl2.n;
if (!itemEntityId)
{
GameWarning("%s: wrong entity id in parameter 2.", __FUNCTION__);
return pH->EndFunction();
}
IGameFramework *pGameFramework = gEnv->pGame->GetIGameFramework();
IItem* pItem = pGameFramework->GetIItemSystem()->GetItem(itemEntityId);
if (!pItem)
{
//gEnv->pAISystem->Warning("<CScriptBind> ", "entity in parameter 2 is not an item/weapon");
GameWarning("%s: entity in parameter 2 is not an item/weapon.", __FUNCTION__);
return pH->EndFunction();
}
float minDist = 7;
bool bSkipTargetCheck = false;
Vec3 targetPos(ZERO);
if(paramCount > 2)
{
for(int i=3;i <= paramCount ; i++)
{
if(pH->GetParamType(i) == svtBool)
pH->GetParam(i,bSkipTargetCheck);
else if(pH->GetParamType(i) == svtNumber)
pH->GetParam(i,minDist);
else if(pH->GetParamType(i) == svtObject)
pH->GetParam(i,targetPos);
}
}
IAIActor* pAIActor = CastToIAIActorSafe(pAI);
if (!pAIActor)
{
GameWarning("%s: entity '%s' in parameter 1 is not an AI actor.", __FUNCTION__, pEntity->GetName());
return pH->EndFunction();
}
IEntity* pItemEntity = pItem->GetEntity();
if(!pItemEntity)
return pH->EndFunction();
if(!pItem->GetOwnerId())
{
// weapon is not used, check if it is on a vehicle
IEntity* pParentEntity = pItemEntity->GetParent();
if(pParentEntity)
{
IAIObject* pParentAI = pParentEntity->GetAI();
if(pParentAI && pParentAI->GetAIType()==AIOBJECT_VEHICLE)
{
// (MATT) Feature was cut and code was tricky, hence ignore weapons in vehicles {2008/02/15:11:08:51}
return pH->EndFunction();
}
}
}
else if( pItem->GetOwnerId()!= pEntity->GetId()) // item is used by someone else?
return pH->EndFunction(false);
// check target
if(bSkipTargetCheck)
return pH->EndFunction(true);
IAIObject* pTarget = pAIActor->GetAttentionTarget();
if(targetPos.IsZero())
{
if(!pTarget)
return pH->EndFunction();
targetPos = pTarget->GetPos();
}
Vec3 targetDir(targetPos - pItemEntity->GetWorldPos());
Vec3 targetDirXY(targetDir.x, targetDir.y, 0);
float length2D = targetDirXY.GetLength();
if(length2D < minDist || length2D<=0)
return pH->EndFunction();
targetDirXY /= length2D;//normalize
IWeapon* pWeapon = pItem->GetIWeapon();
bool vehicleGun = pWeapon && pWeapon->GetHostId();
if (!vehicleGun)
{
Vec3 mountedAngleLimits(pItem->GetMountedAngleLimits());
float yawRange = DEG2RAD(mountedAngleLimits.z);
if(yawRange > 0 && yawRange < gf_PI)
{
float deltaYaw = pItem->GetMountedDir().Dot(targetDirXY);
if(deltaYaw < cosf(yawRange))
return pH->EndFunction(false);
}
float minPitch = DEG2RAD(mountedAngleLimits.x);
float maxPitch = DEG2RAD(mountedAngleLimits.y);
//maxPitch = (maxPitch - minPitch)/2;
//minPitch = -maxPitch;
float pitch = atanf(targetDir.z / length2D);
if ( pitch < minPitch || pitch > maxPitch )
return pH->EndFunction(false);
}
if(pTarget)
{
IEntity* pTargetEntity = pTarget->GetEntity();
if(pTargetEntity)
{
// check target distance and where he's going
IPhysicalEntity *phys = pTargetEntity->GetPhysics();
if(phys)
{
pe_status_dynamics dyn;
phys->GetStatus(&dyn);
Vec3 velocity ( dyn.v);
velocity.z = 0;
float speed = velocity.GetLength2D();
if(speed>0)
{
//velocity /= speed;
if(length2D< minDist * 0.75f && velocity.Dot(targetDirXY)<=0)
return pH->EndFunction(false);
}
}
}
}
return pH->EndFunction(true);
}
void CNetPlayerInput::DoSetState(const SSerializedPlayerInput& input )
{
// PLAYERPREDICTION
m_newInterpolation |= (input.position != m_curInput.position) || (input.deltaMovement != m_curInput.deltaMovement);
m_curInput = input;
CHANGED_NETWORK_STATE(m_pPlayer, IPlayerInput::INPUT_ASPECT );
// not having these set seems to stop a remote avatars rotation being reflected
m_curInput.aiming = true;
m_curInput.allowStrafing = true;
m_curInput.usinglookik = true;
// ~PLAYERPREDICTION
IAIActor* pAIActor = CastToIAIActorSafe(m_pPlayer->GetEntity()->GetAI());
if (pAIActor)
pAIActor->GetState().bodystate=input.bodystate;
CMovementRequest moveRequest;
moveRequest.SetStance( (EStance)m_curInput.stance );
if(IsDemoPlayback())
{
Vec3 localVDir(m_pPlayer->GetViewQuatFinal().GetInverted() * m_curInput.lookDirection);
Ang3 deltaAngles(asinf(localVDir.z),0,cry_atan2f(-localVDir.x,localVDir.y));
moveRequest.AddDeltaRotation(deltaAngles*gEnv->pTimer->GetFrameTime());
}
{
if (m_curInput.usinglookik)
moveRequest.SetLookTarget( m_pPlayer->GetEntity()->GetWorldPos() + 10.0f * m_curInput.lookDirection );
else
moveRequest.ClearLookTarget();
if (m_curInput.aiming)
moveRequest.SetAimTarget(moveRequest.GetLookTarget());
else
moveRequest.ClearAimTarget();
}
/*
float pseudoSpeed = 0.0f;
if (m_curInput.deltaMovement.len2() > 0.0f)
{
pseudoSpeed = m_pPlayer->CalculatePseudoSpeed(m_curInput.sprint);
}
*/
// PLAYERPREDICTION
moveRequest.SetPseudoSpeed(CalculatePseudoSpeed());
// ~PLAYERPREDICTION
moveRequest.SetAllowStrafing(input.allowStrafing);
float lean=0.0f;
if (m_curInput.leanl)
lean-=1.0f;
if (m_curInput.leanr)
lean+=1.0f;
moveRequest.SetLean(lean);
m_pPlayer->GetMovementController()->RequestMovement(moveRequest);
IAnimationGraphState *pState=0;
if (m_pPlayer->GetAnimatedCharacter())
pState=m_pPlayer->GetAnimatedCharacter()->GetAnimationGraphState();
// PLAYERPREDICTION
if (pState)
{
pState->SetInput(m_pPlayer->m_inputAiming, m_curInput.aiming);
pState->SetInput(m_pPlayer->m_inputUsingLookIK, m_curInput.usinglookik);
}
#if !defined(_RELEASE)
// debug..
if (g_pGameCVars->g_debugNetPlayerInput & 1)
{
IPersistantDebug * pPD = gEnv->pGame->GetIGameFramework()->GetIPersistantDebug();
pPD->Begin( string("net_player_input_") + m_pPlayer->GetEntity()->GetName(), true );
pPD->AddSphere( moveRequest.GetLookTarget(), 0.5f, ColorF(1,0,1,1), 1.0f );
// pPD->AddSphere( moveRequest.GetMoveTarget(), 0.5f, ColorF(1,1,0,1), 1.0f );
Vec3 wp(m_pPlayer->GetEntity()->GetWorldPos() + Vec3(0,0,2));
pPD->AddDirection( wp, 1.5f, m_curInput.deltaMovement, ColorF(1,0,0,1), 1.0f );
pPD->AddDirection( wp, 1.5f, m_curInput.lookDirection, ColorF(0,1,0,1), 1.0f );
}
#endif
// ~PLAYERPREDICTION
}
void CDialogActorContext::CancelCurrent(bool bResetStates)
{
if (!m_bNeedsCancel)
return;
assert (m_bInCancel == false);
if (m_bInCancel == true)
return;
m_bInCancel = true;
// remove from AG
if (m_pAGState != 0)
{
m_pAGState->RemoveListener(this);
if (bResetStates)
{
ResetAGState();
}
m_pAGState = 0;
}
m_queryID = 0;
m_bAnimStarted = false;
// reset lookat
IEntity* pEntity = gEnv->pEntitySystem->GetEntity(m_entityID);
if (pEntity)
{
IAIObject* pAI = pEntity->GetAI();
if (pAI)
{
IAIActor* pAIActor = pAI->CastToIAIActor();
if (pAIActor)
{
if (m_bLookAtNeedsReset)
{
pAIActor->ResetLookAt();
m_bLookAtNeedsReset = false;
}
IPipeUser* pPipeUser = pAI->CastToIPipeUser();
if (pPipeUser)
{
if (m_goalPipeID > 0)
{
if (GetAIBehaviourMode() == CDialogSession::eDIB_InterruptMedium)
{
int dummyPipe = 0;
ExecuteAI(dummyPipe, "ACT_DIALOG_OVER", 0, false);
}
pPipeUser->UnRegisterGoalPipeListener( this, m_goalPipeID );
pPipeUser->RemoveSubPipe(m_goalPipeID, true);
m_goalPipeID = 0;
}
if (m_exPosAnimPipeID > 0)
{
pPipeUser->UnRegisterGoalPipeListener( this, m_exPosAnimPipeID );
pPipeUser->CancelSubPipe(m_exPosAnimPipeID);
pPipeUser->RemoveSubPipe(m_exPosAnimPipeID, false);
m_exPosAnimPipeID = 0;
}
}
}
}
}
// facial expression is always reset
// if (bResetStates)
{
// Reset Facial Expression
IEntity* pActorEntity = m_pSession->GetActorEntity(m_actorID);
if (pActorEntity)
{
DoFacialExpression(pActorEntity, "", 1.0f, 0.0f);
}
}
// should we stop the current sound?
// we don't stop the sound if the actor aborts and has eDACF_NoAbortSound set.
// if actor died (entity destroyed) though, sound is stopped anyway
const bool bDontStopSound = (IsAborted() == false && CheckActorFlags(CDialogSession::eDACF_NoAbortSound))
|| (IsAborted()
&& CheckActorFlags(CDialogSession::eDACF_NoAbortSound)
&& GetAbortReason() != CDialogSession::eAR_ActorDead
&& GetAbortReason() != CDialogSession::eAR_EntityDestroyed);
if (bDontStopSound == false)
{
// stop sound (this also forces m_soundId to be INVALID_SOUNDID) and markes Context as non-playing!
// e.g. IsStillPlaying will then return false
// we explicitly stop the sound in the d'tor if we don't take this path here
StopSound();
}
IEntitySystem* pES = gEnv->pEntitySystem;
pES->RemoveEntityEventListener( m_entityID, ENTITY_EVENT_AI_DONE, this );
pES->RemoveEntityEventListener( m_entityID, ENTITY_EVENT_DONE, this );
pES->RemoveEntityEventListener( m_entityID, ENTITY_EVENT_RESET, this );
m_phase = eDAC_Idle;
m_bInCancel = false;
m_bNeedsCancel = false;
}
