void CDragonEnemy::OnPrepare()
{
float dirToPlayer; // the angle of the enemy-player vector
CVector diff; // the vector from the enemy to the player
diff.x = position.x - player->position.x;
diff.z = position.z - player->position.z;
diff.Normalize();
// find the angle in the world of the vector from the enemy to the player
// in relation the negative z-axis
dirToPlayer = RAD2DEG(diff.Angle(CVector(0,0,-1)));
// seed random generator
srand((unsigned int)time(NULL));
ProcessAI();
// now do Ogro prep
// set modelState based on AIstate
switch (aiState)
{
case AI_SCARED:
direction = (dirToPlayer - 90) + ((rand()%90)-45); // set the direction of the enemy
// -90 to 90 degrees
// modelState = MODEL_RUN;
// velocity = CVector(0.0, 0.0, 15.0);
modelState = MODEL_JUMP;
break;
case AI_UNCARING:
direction = float(rand() % 360);
if ((rand() % 4) != 0)
{
modelState = MODEL_IDLE;
velocity = CVector(0.0, 0.0, 0.0);
}
else
{
velocity = CVector(0.0, 0.0, 15.0);
modelState = MODEL_RUN;
}
break;
case AI_DEAD:
modelState = MODEL_DIE;
velocity = CVector(0.0, 0.0, 0.0);
if(nextFrame == 178)
PlaySound();
if (nextFrame == stateStart)
{
// time to kill the monster
isDead = true;
}
break;
default:
break;
}
// do prep for MD2 Model states
CEntity::OnPrepare();
}
void ZActor::OnUpdate(float fDelta)
{
if(m_pVMesh) {
m_pVMesh->SetVisibility(1.f);
}
if (CheckFlag(AF_MY_CONTROL))
{
m_TaskManager.Run(fDelta);
CheckDead(fDelta);
ProcessNetwork(fDelta);
// for test - bird
if (m_bTestControl)
{
TestControl(fDelta);
}
else
{
__BP(60,"ZActor::OnUpdate::ProcessAI");
if(isThinkAble())
ProcessAI(fDelta);
__EP(60);
}
ProcessMovement(fDelta);
}
ProcessMotion(fDelta);
if (CheckFlag(AF_MY_CONTROL))
{
UpdateHeight(fDelta);
}
}
//////////////////////////////////////////////////////////////////////////
// NOTE: This function must be thread-safe. Before adding stuff contact MarcoC.
void CVehicleMovementHelicopter::ProcessMovement(const float deltaTime)
{
FUNCTION_PROFILER( GetISystem(), PROFILE_GAME );
IPhysicalEntity* pPhysics = GetPhysics();
assert(pPhysics);
if (m_arcade.m_handling.maxSpeedForward>0.f) // Use the new handling code
{
CryAutoCriticalSection lk(m_lock);
if (!m_isEnginePowered)
return;
CVehicleMovementBase::ProcessMovement(deltaTime);
SVehiclePhysicsStatus* physStatus = &m_physStatus[k_physicsThread];
if(m_bApplyNoiseAsVelocity)
{
physStatus->v -= m_pNoise->m_posDifference;
physStatus->w -= m_pNoise->m_angDifference;
m_pNoise->Update(deltaTime);
}
///////////////////////////////////////////////////////////////
// Pass on the movement request to the active physics handler
// NB: m_physStatus is update by this call
SVehiclePhysicsHelicopterProcessParams params;
params.pPhysics = pPhysics;
params.pPhysStatus = physStatus;
params.pInputAction = &m_inputAction;
params.dt = deltaTime;
params.haveDriver = (m_actorId!=0)||m_remotePilot;
params.isAI = m_movementAction.isAI;
params.aiRequiredVel = m_CurrentVel;
m_arcade.ProcessMovement(params);
// Network error adjustment
m_netPosAdjust *= max(0.f, 1.f-deltaTime*k_netErrorPosScale);
physStatus->v += m_netPosAdjust * k_netErrorPosScale;
if(m_bApplyNoiseAsVelocity)
{
physStatus->v += m_pNoise->m_posDifference;
physStatus->w += m_pNoise->m_angDifference;
}
//===============================================
// Commit the velocity back to the physics engine
//===============================================
// if (fabsf(m_movementAction.rotateYaw)>0.05f || vel.GetLengthSquared()>0.001f || m_chassis.vel.GetLengthSquared()>0.001f || angVel.GetLengthSquared()>0.001f || angVel.GetLengthSquared()>0.001f)
{
pe_action_set_velocity setVelocity;
setVelocity.v = physStatus->v;
setVelocity.w = physStatus->w;
pPhysics->Action(&setVelocity, 1);
}
///////////////////////////////////////////////////////////////
}
else
{
if (m_isEnginePowered && pPhysics)
{
m_movementAction.isAI = true;
pe_status_pos psp;
pe_status_dynamics psd;
if (!pPhysics->GetStatus(&psp) || !pPhysics->GetStatus(&psd))
return;
UpdatePhysicsStatus(&m_physStatus[k_physicsThread], &psp, &psd);
ProcessAI(deltaTime);
}
}
}
