//------------------------------------------------------------------------
CVehicleActionEntityAttachment *CFlowVehicleEntityAttachment::GetVehicleAction()
{
if(!m_vehicleId)
return NULL;
IVehicleSystem *pVehicleSystem = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem();
assert(pVehicleSystem);
if(IVehicle *pVehicle = pVehicleSystem->GetVehicle(m_vehicleId))
{
for(int i = 1; i < pVehicle->GetActionCount(); i++)
{
IVehicleAction *pAction = pVehicle->GetAction(i);
assert(pAction);
if(CVehicleActionEntityAttachment *pAttachment =
CAST_VEHICLEOBJECT(CVehicleActionEntityAttachment, pAction))
{
return pAttachment;
}
}
}
return NULL;
}
//------------------------------------------------------------------------
void CFlowVehicleAttachment::Attach(SActivationInfo* pActInfo, bool attach)
{
IVehicle* pVehicle = GetVehicle();
if (!pVehicle)
return;
IVehiclePart* pPart = pVehicle->GetPart(GetPortString(pActInfo, IN_ATTACHMENT).c_str());
if (!pPart)
return;
CVehiclePartEntityAttachment* pAttachment = CAST_VEHICLEOBJECT(CVehiclePartEntityAttachment, pPart);
if (!pAttachment)
return;
if (!attach)
{
pAttachment->SetAttachmentEntity(0);
m_attachedId = 0;
}
else
{
EntityId entityId = GetPortEntityId(pActInfo, IN_ENTITYID);
pAttachment->SetAttachmentEntity(entityId);
m_attachedId = entityId;
}
}
//------------------------------------------------------------------------
void CVehicleMovementHelicopter::PostInit()
{
CVehicleMovementBase::PostInit();
m_pRotorHelper = m_pVehicle->GetHelper("rotorSmokeOut");
for (int i = 0; i < m_pVehicle->GetActionCount(); i++)
{
IVehicleAction* pAction = m_pVehicle->GetAction(i);
if(pAction)
{
m_pLandingGears = CAST_VEHICLEOBJECT(CVehicleActionLandingGears, pAction);
if (m_pLandingGears)
break;
}
}
Reset();
}
//------------------------------------------------------------------------
bool CVehicleDamagesGroup::IsPotentiallyFatal()
{
for (TDamagesSubGroupVector::iterator subGroupIte = m_damageSubGroups.begin(); subGroupIte != m_damageSubGroups.end(); ++subGroupIte)
{
SDamagesSubGroup& subGroup = *subGroupIte;
TVehicleDamageBehaviorVector& damageBehaviors = subGroup.m_damageBehaviors;
for (TVehicleDamageBehaviorVector::iterator behaviorIte = damageBehaviors.begin(); behaviorIte != damageBehaviors.end(); ++behaviorIte)
{
//IVehicleDamageBehavior* pBehavio
if (CVehicleDamageBehaviorDestroy* pBehaviorDestroy =
CAST_VEHICLEOBJECT(CVehicleDamageBehaviorDestroy, (*behaviorIte)))
{
return true;
}
}
}
return false;
}
void CFlowVehicleTurret::ProcessEvent(EFlowEvent event, SActivationInfo* pActInfo)
{
CFlowVehicleBase::ProcessEvent(event, pActInfo); // handles eFE_SetEntityId
if (event == eFE_Activate)
{
if (IsPortActive(pActInfo, eIn_Trigger))
{
bool bSuccess = false;
const string seatName = GetPortString(pActInfo, eIn_Seat);
Vec3 aimPos = GetPortVec3(pActInfo, eIn_AimPos);
CVehicle* pVehicle = static_cast<CVehicle*>(GetVehicle());
if (pVehicle)
{
CVehicleSeat* pSeat = static_cast<CVehicleSeat*>(pVehicle->GetSeatById(pVehicle->GetSeatId(seatName)));
if (pSeat)
{
TVehicleSeatActionVector &seatActions = pSeat->GetSeatActions();
for (TVehicleSeatActionVector::iterator ite = seatActions.begin(); ite != seatActions.end(); ++ite)
{
IVehicleSeatAction* pSeatAction = ite->pSeatAction;
CVehicleSeatActionRotateTurret* pActionRotateTurret = CAST_VEHICLEOBJECT(CVehicleSeatActionRotateTurret, pSeatAction);
if (pActionRotateTurret)
{
if (!aimPos.IsZero())
{
pActionRotateTurret->SetAimGoal(aimPos);
}
bSuccess = true;
break;
}
}
}
}
ActivateOutput( pActInfo, eOut_Success, bSuccess );
}
}
}
//------------------------------------------------------------------------
void CVehicleMovementHelicopter::PostInit()
{
CVehicleMovementBase::PostInit();
m_HoverAnim = m_pVehicle->GetAnimation("hover");
m_pRotorHelper = m_pVehicle->GetHelper("rotorSmokeOut");
for (int i = 0; i < m_pVehicle->GetActionCount(); i++)
{
IVehicleAction* pAction = m_pVehicle->GetAction(i);
m_pLandingGears = CAST_VEHICLEOBJECT(CVehicleActionLandingGears, pAction);
if (m_pLandingGears)
break;
}
if (!gEnv->IsEditor())
{
Reset();
}
OccupyWeaponSeats();
}
void CFlowNode_AISequenceAction_VehicleRotateTurret::HandleSequenceEvent(AIActionSequence::SequenceEvent sequenceEvent)
{
switch(sequenceEvent)
{
case AIActionSequence::StartAction:
{
if (!m_actInfo.pEntity)
{
// the entity has gone for some reason, at least make sure the action gets finished properly and the FG continues
CancelSequenceAndActivateOutputPort(OutputPort_Done);
return;
}
assert(gEnv && gEnv->pGame && gEnv->pGame->GetIGameFramework() && gEnv->pGame->GetIGameFramework()->GetIActorSystem());
IActor* pActor = gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(m_actInfo.pEntity->GetId());
// ensure the FG entity is an IActor
if (!pActor)
{
CRY_ASSERT_MESSAGE(0, "no compatible entity was provided");
CryWarning(VALIDATOR_MODULE_AI, VALIDATOR_WARNING, "Actor %s failed to enter vehicle (no compatible entity was provided)", m_actInfo.pEntity->GetName());
CancelSequenceAndActivateOutputPort(OutputPort_Done);
return;
}
// get the vehicle the actor is linked to
IVehicle* pVehicle = pActor->GetLinkedVehicle();
if (!pVehicle)
{
CRY_ASSERT_MESSAGE(0, "agent is not linked to a vehicle");
CryWarning(VALIDATOR_MODULE_AI, VALIDATOR_WARNING, "Actor %s is not linked to a vehicle", m_actInfo.pEntity->GetName());
CancelSequenceAndActivateOutputPort(OutputPort_Done);
return;
}
// get the seat the actor is sitting on
CVehicleSeat* pSeat = static_cast<CVehicleSeat*>(pVehicle->GetSeatForPassenger(m_actInfo.pEntity->GetId()));
if (!pSeat)
{
CRY_ASSERT_MESSAGE(0, "agent is not sitting in the vehicle it is linked to");
CryWarning(VALIDATOR_MODULE_AI, VALIDATOR_WARNING, "Actor %s is not sitting in the vehicle it is linked to", m_actInfo.pEntity->GetName());
CancelSequenceAndActivateOutputPort(OutputPort_Done);
return;
}
// scan for the seat-action that allows rotating the turret
TVehicleSeatActionVector& seatActions = pSeat->GetSeatActions();
for (TVehicleSeatActionVector::iterator it = seatActions.begin(); it != seatActions.end(); ++it)
{
IVehicleSeatAction* pSeatAction = it->pSeatAction;
if ((m_pActionRotateTurret = CAST_VEHICLEOBJECT(CVehicleSeatActionRotateTurret, pSeatAction)))
{
break;
}
}
// ensure the vehicle-seat provided the correct action
if (!m_pActionRotateTurret)
{
CRY_ASSERT_MESSAGE(0, "a CVehicleSeatActionRotateTurret is not provided by the vehicle or someone else in the vehicle has reserved that action already.");
CryWarning(VALIDATOR_MODULE_AI, VALIDATOR_WARNING, "Actor %s could not find a CVehicleSeatActionRotateTurret or that action is already reserved by someone else", m_actInfo.pEntity->GetName());
CancelSequenceAndActivateOutputPort(OutputPort_Done);
return;
}
m_pitchThreshold = GetPortFloat(&m_actInfo, InputPort_ThresholdPitch);
m_yawThreshold = GetPortFloat(&m_actInfo, InputPort_ThresholdYaw);
Vec3 aimPos = GetPortVec3(&m_actInfo, InputPort_AimPos);
m_pActionRotateTurret->SetAimGoal(aimPos);
}
break;
case AIActionSequence::SequenceStopped:
{
if (m_pActionRotateTurret)
{
// cancel the rotation action
m_pActionRotateTurret->SetAimGoal(Vec3Constants<float>::fVec3_Zero);
m_pActionRotateTurret = NULL;
}
}
break;
}
}
//------------------------------------------------------------------------
bool CVehicleDamagesGroup::ParseDamagesGroup(const CVehicleParams& table)
{
if (table.haveAttr("useTemplate"))
{
IVehicleSystem* pVehicleSystem = gEnv->pGame->GetIGameFramework()->GetIVehicleSystem();
CRY_ASSERT(pVehicleSystem);
if (IVehicleDamagesTemplateRegistry* pDamageTemplReg = pVehicleSystem->GetDamagesTemplateRegistry())
pDamageTemplReg->UseTemplate(table.getAttr("useTemplate"), this);
}
if (CVehicleParams damagesSubGroupsTable = table.findChild("DamagesSubGroups"))
{
int i = 0;
int c = damagesSubGroupsTable.getChildCount();
for (; i < c; i++)
{
if (CVehicleParams groupTable = damagesSubGroupsTable.getChild(i))
{
m_damageSubGroups.resize(m_damageSubGroups.size() + 1);
SDamagesSubGroup& subGroup = m_damageSubGroups.back();
subGroup.id = m_damageSubGroups.size() - 1;
subGroup.m_isAlreadyInProcess = false;
if (!groupTable.getAttr("delay", subGroup.m_delay))
subGroup.m_delay = 0.0f;
if (!groupTable.getAttr("randomness", subGroup.m_randomness))
subGroup.m_randomness = 0.0f;
if (CVehicleParams damageBehaviorsTable = groupTable.findChild("DamageBehaviors"))
{
int k = 0;
int numDamageBehaviors = damageBehaviorsTable.getChildCount();
subGroup.m_damageBehaviors.reserve(c);
for (; k < numDamageBehaviors; k++)
{
if (CVehicleParams behaviorTable = damageBehaviorsTable.getChild(k))
{
if (IVehicleDamageBehavior* pDamageBehavior = ParseDamageBehavior(behaviorTable))
{
subGroup.m_damageBehaviors.push_back(pDamageBehavior);
CVehicleDamageBehaviorDestroy *pDamageDestroy = CAST_VEHICLEOBJECT(CVehicleDamageBehaviorDestroy, pDamageBehavior);
if (pDamageDestroy)
{
TVehiclePartVector& parts = m_pVehicle->GetParts();
for (TVehiclePartVector::iterator ite = parts.begin(); ite != parts.end(); ++ite)
{
IVehiclePart* pPart = ite->second;
if (CVehiclePartAnimatedJoint* pAnimJoint = CAST_VEHICLEOBJECT(CVehiclePartAnimatedJoint, pPart))
{
if (pAnimJoint->IsPhysicalized() && !pAnimJoint->GetDetachBaseForce().IsZero())
{
CVehicleDamageBehaviorDetachPart* pDetachBehavior = new CVehicleDamageBehaviorDetachPart;
pDetachBehavior->Init(m_pVehicle, pAnimJoint->GetName(), pDamageDestroy->GetEffectName());
subGroup.m_damageBehaviors.push_back(pDetachBehavior);
}
}
}
}
}
}
}
}
}
}
}
return true;
}
bool CVehiclePartSuspensionPart::Init(IVehicle *pVehicle, const CVehicleParams &table, IVehiclePart *pParent, CVehicle::SPartInitInfo &initInfo, int partType)
{
if (!inherited::Init(pVehicle, table, pParent, initInfo, partType))
return false;
m_animatedRoot = CAST_VEHICLEOBJECT(CVehiclePartAnimated, GetParent(true));
m_jointId = -1;
m_ikFlags = 0;
if (m_animatedRoot)
{
if(CVehicleParams subPartTable = table.findChild("SubPart"))
{
// We need to remove this part from the animated root, otherwise we have two parts
// NB: for now we are not doing anything with the physics - infact its preferable
// if we dont have physics on suspension arms!
const char* geoName = subPartTable.getAttr("geometryname");
ICharacterInstance* pCharInstance = m_animatedRoot->GetEntity()->GetCharacter(m_animatedRoot->GetSlot());
if (pCharInstance)
{
IDefaultSkeleton& rIDefaultSkeleton = pCharInstance->GetIDefaultSkeleton();
ISkeletonPose* pSkeletonPose = pCharInstance->GetISkeletonPose();
m_jointId = rIDefaultSkeleton.GetJointIDByName(geoName);
pSkeletonPose->SetStatObjOnJoint(m_jointId, NULL);
}
}
}
else
{
CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "CVehiclePartSuspensionPart: needs to have an AnimatedPart as a parent!");
return false;
}
CVehicleParams ikTable = table.findChild("IK");
if (!ikTable)
return false;
const char* targetPartName = ikTable.getAttr("target");
m_targetPart = static_cast<CVehiclePartBase*>(pVehicle->GetPart(targetPartName));
if (m_targetPart==NULL)
{
CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "CVehiclePartSuspensionPart: couldn't find target part: '%s'", targetPartName);
return false;
}
// Set up the target
m_targetOffset.zero();
const char* targetHelper = ikTable.getAttr("targetHelper");
if (targetHelper && targetHelper[0])
{
if (IVehicleHelper* pHelper = m_pVehicle->GetHelper(targetHelper))
{
// NB: this is in vehicle space, and needs translating in PostInit()
m_targetOffset = pHelper->GetLocalTM().GetTranslation();
m_ikFlags |= k_flagTargetHelper;
}
}
Vec3 offset(0);
ikTable.getAttr("offset", offset);
m_targetOffset += offset;
m_mode = k_modeStretch;
const char* mode = ikTable.getAttr("mode");
if (strcmp(mode,"rotate")==0)
m_mode = k_modeRotate;
if (strcmp(mode,"stretch")==0)
m_mode = k_modeStretch;
if (strcmp(mode,"snap")==0)
m_mode = k_modeSnapToEF;
bool bIgnoreTargetRotation=0;
ikTable.getAttr("ignoreTargetRotation", bIgnoreTargetRotation);
if (bIgnoreTargetRotation)
m_ikFlags |= k_flagIgnoreTargetRotation;
return true;
}
