void execute(CItem *pItem)
{
_this->m_attacking = false;
_this->m_slideKick = false;
_this->m_netAttacking = false;
_this->m_delayTimer = 0.0f;
pItem->SetBusy(false);
pItem->ForcePendingActions();
MeleeDebugLog ("CMelee<%p> StopAttackingAction is being executed!", _this);
CActor* pActor(NULL);
if(!gEnv->bMultiplayer)
{
if (IEntity* owner = pItem->GetOwner())
if (IAIObject* aiObject = owner->GetAI())
if (IAIActor* aiActor = aiObject->CastToIAIActor())
aiActor->SetSignal(0, "OnMeleePerformed");
}
else if( g_pGameCVars->pl_melee.mp_melee_system_camera_lock_and_turn && s_meleeSnapTargetId && (pActor = pItem->GetOwnerActor()) && pActor->IsClient() )
{
CActor* pOwnerActor = pItem->GetOwnerActor();
pOwnerActor->GetActorParams().viewLimits.ClearViewLimit(SViewLimitParams::eVLS_Item);
s_meleeSnapTargetId = 0;
CHANGED_NETWORK_STATE(pOwnerActor, CPlayer::ASPECT_SNAP_TARGET);
}
if(_this->m_pMeleeAction)
{
SAFE_RELEASE(_this->m_pMeleeAction);
}
}
//------------------------------------------------------------------------
void CWeapon::RequestStartMeleeAttack(bool weaponMelee, bool boostedAttack, int8 attackIndex /*= -1*/)
{
CActor *pActor=GetOwnerActor();
if (!gEnv->bServer && pActor && pActor->IsClient())
{
GetGameObject()->InvokeRMI(CWeapon::SvRequestStartMeleeAttack(), MeleeRMIParams(boostedAttack,attackIndex), eRMI_ToServer);
#ifndef _RELEASE
if(g_pGameCVars->pl_pickAndThrow.environmentalWeaponComboDebugEnabled)
{
CryLogAlways("COMBO - RequestStartMeleeAttack - called by NON SERVER client with attack index [%d]",attackIndex);
CryLogAlways("COMBO - RequestStartMeleeAttack - calling SvRequestStartMeleeAttack");
}
#endif //#ifndef _RELEASE
}
else if (IsServer())
{
m_attackIndex = attackIndex;
m_meleeCounter = (m_meleeCounter + 1) % kMeleeCounterMax;
#ifndef _RELEASE
if(g_pGameCVars->pl_pickAndThrow.environmentalWeaponComboDebugEnabled)
{
CryLogAlways("COMBO - RequestStartMeleeAttack - called by server, about to netserialising to clients w A.Index. [%d]", m_attackIndex);
}
#endif //#ifndef _RELEASE
CHANGED_NETWORK_STATE(this, ASPECT_MELEE);
}
}
//---------------------------------------------------------------------
void CMelee::RequestAlignmentToNearestTarget()
{
CActor* pOwner = m_pWeapon->GetOwnerActor();
if(pOwner && pOwner->IsClient())
{
if (!s_meleeSnapTargetId)
{
// If we don't already have an auto-aim target, try and find one.
if (s_meleeSnapTargetId = GetNearestTarget())
{
IActor* pTargetActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(s_meleeSnapTargetId);
s_bMeleeSnapTargetCrouched = pTargetActor && static_cast<CPlayer*>(pTargetActor)->GetStance() == STANCE_CROUCH;
CHANGED_NETWORK_STATE(pOwner, CPlayer::ASPECT_SNAP_TARGET);
}
}
if(!s_meleeSnapTargetId || m_netAttacking)
return;
if(pOwner && pOwner->IsClient() && m_pMeleeAction && g_pGameCVars->pl_melee.mp_melee_system_camera_lock_and_turn)
{
pOwner->GetActorParams().viewLimits.SetViewLimit(pOwner->GetViewRotation().GetColumn1(), 0.01f, 0.01f, 0.01f, 0.01f, SViewLimitParams::eVLS_Item);
}
g_pGame->GetAutoAimManager().SetCloseCombatSnapTarget(s_meleeSnapTargetId,
g_pGameCVars->pl_melee.melee_snap_end_position_range,
g_pGameCVars->pl_melee.melee_snap_move_speed_multiplier);
}
}
bool CNetworkBuilding::Building(int part)
{
if(part>0)
{
if(part==1)
{
CryLog("CNetworkBuilding::Building part 1...");
// Geometry
GetEntity()->LoadGeometry(0, model_1);
// Material
IMaterial *pMat = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(Model_1_mat);
GetEntity()->SetMaterial(pMat);
// Physics
Physicalize((pe_type)phys_type);
}
if(part==2)
{
CryLog("CNetworkBuilding::Building part 2...");
GetEntity()->LoadGeometry(0, model_2);
IMaterial *pMat = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(Model_2_mat);
GetEntity()->SetMaterial(pMat);
Physicalize((pe_type)phys_type);
}
if(part==3)
{
CryLog("CNetworkBuilding::Building part 3...");
GetEntity()->LoadGeometry(0, model_3);
IMaterial *pMat = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(Model_3_mat);
GetEntity()->SetMaterial(pMat);
Physicalize((pe_type)phys_type);
}
if(part==4)
{
CryLog("CNetworkBuilding::Building finish part...");
GetEntity()->LoadGeometry(0, finish_model);
IMaterial *pMat = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(finishMat);
GetEntity()->SetMaterial(pMat);
Physicalize((pe_type)phys_type);
m_state = eState_Done;
CryLog("CNetworkBuilding::Building finished !");
}
if (gEnv->bServer)
{
CHANGED_NETWORK_STATE(this, POSITION_ASPECT);
}
}
return true;
}
void CMonoActor::SetAuthority( bool auth )
{
// we've been given authority of this entity, mark the physics as changed
// so that we send a current position, failure to do this can result in server/client
// disagreeing on where the entity is. most likely to happen on restart
if(auth)
CHANGED_NETWORK_STATE(this, eEA_Physics);
}
//------------------------------------------------------------------------
IMPLEMENT_RMI(CWeapon, SvRequestWeaponRaised)
{
CHECK_OWNER_REQUEST();
CHANGED_NETWORK_STATE(this, ASPECT_STREAM);
return true;
}
void CDangerousRigidBody::SetIsDangerous( bool isDangerous, EntityId triggerPlayerId )
{
if(gEnv->bServer && isDangerous != m_dangerous)
{
m_dangerous = isDangerous;
m_activatorTeam = g_pGame->GetGameRules()->GetTeam(triggerPlayerId);
CHANGED_NETWORK_STATE(this, ASPECT_DAMAGE_STATUS);
}
}
bool CTornado::Reset()
{
//Initialize default values before (in case ScriptTable fails)
m_wanderSpeed = 10.0f;
m_cloudHeight = 376.0f;
m_radius = 300.0f;
m_spinImpulse = 9.0f;
m_attractionImpulse = 13.0f;
m_upImpulse = 18.0f;
const char* funnelEffect = 0;
SmartScriptTable props;
IScriptTable* pScriptTable = GetEntity()->GetScriptTable();
if(!pScriptTable || !pScriptTable->GetValue("Properties", props))
return false;
props->GetValue("fWanderSpeed", m_wanderSpeed);
props->GetValue("fCloudHeight", m_cloudHeight);
props->GetValue("Radius", m_radius);
props->GetValue("fSpinImpulse", m_spinImpulse);
props->GetValue("fAttractionImpulse", m_attractionImpulse);
props->GetValue("fUpImpulse", m_upImpulse);
props->GetValue("FunnelEffect", funnelEffect);
if (!UseFunnelEffect(funnelEffect))
return false;
Matrix34 m = GetEntity()->GetWorldTM();
m_wanderDir = m.GetColumn(1)*0.414214f;
m_isOnWater = false;
m_isInAir = false;
m_nextEntitiesCheck = 0;
Vec3 pos = GetEntity()->GetWorldPos();
gEnv->pLog->Log("TORNADO INIT POS: %f %f %f", pos.x, pos.y, pos.z);
m_points[0] = pos;
m_points[1] = pos + Vec3(0,0,m_cloudHeight/8.0f);
m_points[2] = pos + Vec3(0,0,m_cloudHeight/2.0f);
m_points[3] = pos + Vec3(0,0,m_cloudHeight);
for (int i=0; i<4; ++i)
m_oldPoints[i] = m_points[i];
m_currentPos = GetEntity()->GetWorldPos();
CHANGED_NETWORK_STATE(this, POSITION_ASPECT);
UpdateTornadoSpline();
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
}
void CNetPlayerInput::Update()
{
if (gEnv->bServer && (g_pGameCVars->sv_input_timeout>0) && ((gEnv->pTimer->GetFrameStartTime()-m_lastUpdate).GetMilliSeconds()>=g_pGameCVars->sv_input_timeout))
{
m_curInput.deltaMovement.zero();
m_curInput.sprint=false;
m_curInput.stance=(uint8)STANCE_NULL;
CHANGED_NETWORK_STATE(m_pPlayer, CPlayer::ASPECT_INPUT_CLIENT );
}
}
void CNetworkBuilding::StartBuild()
{
if(m_state==eState_NotUsed && gEnv->bServer)
{
CryLog("CNetworkBuilding::Building started...");
m_state = eState_InUse;
build_status = 0;
fStartTime = gEnv->pTimer->GetAsyncTime().GetSeconds();
CHANGED_NETWORK_STATE(this, POSITION_ASPECT);
}
}
//------------------------------------------------------------------------
IMPLEMENT_RMI(CWeapon, SvRequestShoot)
{
CHECK_OWNER_REQUEST();
bool ok=true;
CActor *pActor=GetActorByNetChannel(pNetChannel);
if (!pActor || pActor->IsDead())
ok=false;
if (ok)
{
m_fireCounter++;
m_expended_ammo++;
IActor *pLocalActor=m_pGameFramework->GetClientActor();
bool isLocal = pLocalActor && (pLocalActor->GetChannelId() == pActor->GetChannelId());
#ifdef SERVER_CHECKS
const float fCurrentTime = gEnv->pTimer->GetAsyncCurTime();
const int kOldShotId = m_lastShotId;
if(ShouldEndVerificationSample(fCurrentTime, params.shotId))
{
EndVerificationSample(pActor, kOldShotId);
StartVerificationSample(fCurrentTime);
}
m_fLastSampleTakenTime = fCurrentTime;
m_fSampleNumShots += 1.0f;
CPlayer * pPlayer = static_cast<CPlayer*>(pActor);
pPlayer->GetShotCounter()->RecordShot();
#endif
if (!isLocal)
{
NetShoot(params.hit, 0, params.fireModeId);
}
CHANGED_NETWORK_STATE(this, ASPECT_STREAM);
}
#ifdef SERVER_CHECKS
CGameRules * pGameRules = static_cast<CGameRules*>(g_pGame->GetGameRules());
if(pGameRules) //really we should assert here. I struggle to think of a situation where someone is requesting a shot but there are no GameRules...
{
IGameRulesDamageHandlingModule * pDamageHandler = pGameRules->GetDamageHandlingModule();
assert(pDamageHandler);
pDamageHandler->RegisterShotIdentification(pActor->GetEntityId(), this, params.shotId);
}
#endif
return true;
}
//------------------------------------------------------------------------
IMPLEMENT_RMI(CWeapon, SvRequestSetZoomState)
{
CHECK_OWNER_REQUEST();
if (params.zoomed)
StartZoom(m_owner.GetId(), 1);
else
StopZoom(m_owner.GetId());
CHANGED_NETWORK_STATE(this, ASPECT_STREAM);
return true;
}
IMPLEMENT_RMI(CHeavyMountedWeapon, SvRequestRipOff)
{
CHECK_OWNER_REQUEST();
if (!m_rippingOff && !m_rippedOff)
{
PerformRipOff(GetOwnerActor());
CHANGED_NETWORK_STATE(this, ASPECT_RIPOFF);
}
return true;
}
//------------------------------------------------------------------------
IMPLEMENT_RMI(CWeapon, SvStartedCharging)
{
CHECK_OWNER_REQUEST();
if(CFireMode* pFireMode = static_cast<CFireMode*>(GetFireMode(GetCurrentFireMode())))
{
pFireMode->NetSetCharging(true);
CHANGED_NETWORK_STATE(this, ASPECT_CHARGING);
}
return true;
}
//========================================================================
void CPlant::SetProjectileId(EntityId id)
{
if(id)
{
bool changed = m_projectiles.empty();
stl::push_back_unique(m_projectiles,id);
if(changed)
{
CHANGED_NETWORK_STATE(m_pWeapon, CC4::ASPECT_DETONATE);
}
}
}
//------------------------------------------------------------------------
void CWeapon::RequestWeaponRaised(bool raise)
{
if(gEnv->bMultiplayer)
{
CActor* pActor = GetOwnerActor();
if(pActor && pActor->IsClient())
{
if (gEnv->bServer)
CHANGED_NETWORK_STATE(this, ASPECT_STREAM);
else
GetGameObject()->InvokeRMI(SvRequestWeaponRaised(), WeaponRaiseParams(raise), eRMI_ToServer);
}
}
}
//------------------------------------------------------------------------
void CWeapon::RequestSetZoomState(bool zoomed)
{
if(gEnv->bMultiplayer)
{
CActor* pActor = GetOwnerActor();
if(pActor && pActor->IsClient())
{
if (gEnv->bServer)
CHANGED_NETWORK_STATE(this, ASPECT_STREAM);
else
GetGameObject()->InvokeRMI(SvRequestSetZoomState(), ZoomStateParams(zoomed), eRMI_ToServer);
}
}
}
//=====================================================================
EntityId CPlant::RemoveProjectileId()
{
EntityId id = 0;
if(!m_projectiles.empty())
{
id= m_projectiles.back();
m_projectiles.pop_back();
if(m_projectiles.empty())
{
CHANGED_NETWORK_STATE(m_pWeapon, CC4::ASPECT_DETONATE);
}
}
return id;
}
void CHeavyMountedWeapon::ForceRippingOff( bool ripOff )
{
SetRippingOff(ripOff);
if (ripOff)
{
// If we're forcing to ripped-off, make sure we're using the right firemode (firemode is server
// controlled so may have lost during a host migration)
SwitchToRippedOffFireMode();
}
if (gEnv->bServer)
{
CHANGED_NETWORK_STATE(this, ASPECT_RIPOFF);
}
}
void CMelee::OnSuccesfulHit( const ray_hit& hitResult )
{
CActor* pOwner = m_pWeapon->GetOwnerActor();
if( IsMeleeWeapon() && m_hitStatus != EHitStatus_ReceivedAnimEvent && hitResult.pCollider )
{
// we defer the MeleeDamage until the MeleeHitEvent is received!
m_lastCollisionTest = m_collisionHelper.GetCollisionTestParams();
m_lastRayHit = hitResult;
m_lastRayHit.pCollider->AddRef();
m_hitStatus = EHitStatus_HaveHitResult;
}
else
{
const SCollisionTestParams& collisionParams = m_collisionHelper.GetCollisionTestParams();
ApplyMeleeDamageHit( collisionParams, hitResult );
m_hitStatus = EHitStatus_Invalid;
if(m_pMeleeAction)
{
if(pOwner)
{
m_pMeleeAction->OnHitResult(pOwner, true);
}
else
{
//Owner has dropped weapon (Likely from being killed) so we can stop and release the action
m_pMeleeAction->ForceFinish();
SAFE_RELEASE(m_pMeleeAction);
}
}
}
if(pOwner && pOwner->IsClient())
{
s_meleeSnapTargetId = 0;
CHANGED_NETWORK_STATE(pOwner, CPlayer::ASPECT_SNAP_TARGET);
if(g_pGameCVars->pl_melee.mp_melee_system_camera_lock_and_turn)
{
pOwner->GetActorParams().viewLimits.ClearViewLimit(SViewLimitParams::eVLS_Item);
}
}
}
void CMelee::OnFailedHit()
{
const SCollisionTestParams& collisionParams = m_collisionHelper.GetCollisionTestParams();
bool collided = PerformCylinderTest(collisionParams.m_pos, collisionParams.m_dir, collisionParams.m_remote);
CActor* pOwner = m_pWeapon->GetOwnerActor();
if(pOwner && pOwner->IsClient())
{
if(!collided && s_meleeSnapTargetId)
{
Vec3 ownerpos = pOwner->GetEntity()->GetWorldPos();
IEntity* pTarget = gEnv->pEntitySystem->GetEntity(s_meleeSnapTargetId);
if(pTarget && ownerpos.GetSquaredDistance(pTarget->GetWorldPos()) < cry_sqr(GetRange() * m_pMeleeParams->meleeparams.target_range_mult))
{
collided = m_collisionHelper.PerformMeleeOnAutoTarget(s_meleeSnapTargetId);
}
}
s_meleeSnapTargetId = 0;
CHANGED_NETWORK_STATE(pOwner, CPlayer::ASPECT_SNAP_TARGET);
if(g_pGameCVars->pl_melee.mp_melee_system_camera_lock_and_turn)
{
pOwner->GetActorParams().viewLimits.ClearViewLimit(SViewLimitParams::eVLS_Item);
}
}
if(m_pMeleeAction)
{
if(pOwner)
{
m_pMeleeAction->OnHitResult(pOwner, collided);
}
else
{
//Owner has dropped weapon (Likely from being killed) so we can stop and release the action
m_pMeleeAction->ForceFinish();
SAFE_RELEASE(m_pMeleeAction);
}
}
ApplyMeleeEffects(collided);
}
void CHeavyMountedWeapon::TryRipOffGun()
{
CActor *pActor = GetOwnerActor();
if(!pActor)
return;
PerformRipOff(pActor);
if(gEnv->bServer)
{
CHANGED_NETWORK_STATE(this, ASPECT_RIPOFF);
}
else
{
GetGameObject()->InvokeRMI(SvRequestRipOff(), EmptyParams(), eRMI_ToServer);
}
}
bool CNetworkBuilding::Reset()
{
if(!GetSettings())
return false;
entity_name = GetEntity()->GetName();
fStartTime = 0.f;
build_status = -1;
m_state = eState_NotUsed;
GetEntity()->LoadGeometry(0,default_model);
GetEntity()->SetMaterial(defMat);
Physicalize(PE_NONE);
CHANGED_NETWORK_STATE(this, POSITION_ASPECT);
return true;
}
void CPlayerPlugin_CurrentlyTargetting::Update(float dt)
{
m_currentTargetTime += dt; //updated locally for all players (so doesn't have to be synced)
assert (IsEntered());
if (m_ownerPlayer->IsClient())
{
EntityId newTargetId = !m_ownerPlayer->IsDead() ? m_ownerPlayer->GetGameObject()->GetWorldQuery()->GetLookAtEntityId() : 0;
if (newTargetId)
{
IActor * targettedActor = g_pGame->GetIGameFramework()->GetIActorSystem()->GetActor(newTargetId);
if (targettedActor == NULL || targettedActor->IsDead())
{
newTargetId = 0;
}
}
if (m_currentTarget != newTargetId)
{
m_currentTarget = newTargetId;
CCCPOINT_IF(m_currentTarget, PlayerState_LocalPlayerNowTargettingSomebody);
CCCPOINT_IF(!m_currentTarget, PlayerState_LocalPlayerNowTargettingNobody);
m_currentTargetTime = 0.0f;
CHANGED_NETWORK_STATE(m_ownerPlayer, CPlayer::ASPECT_CURRENTLYTARGETTING_CLIENT);
}
}
#if PLAYER_PLUGIN_DEBUGGING
IEntity* pEntity = gEnv->pEntitySystem->GetEntity(m_currentTarget);
PlayerPluginWatch ("Target e%05d (%s %s) - %.2f", m_currentTarget, pEntity ? pEntity->GetName() : "NULL", pEntity ? pEntity->GetClass()->GetName() : "entity", m_currentTargetTime);
#endif
}
//------------------------------------------------------------------------
IMPLEMENT_RMI(CWeapon, SvRequestStartMeleeAttack)
{
CHECK_OWNER_REQUEST();
CActor *pActor=GetActorByNetChannel(pNetChannel);
IActor *pLocalActor=m_pGameFramework->GetClientActor();
bool isLocal = pLocalActor && pActor && (pLocalActor->GetChannelId() == pActor->GetChannelId());
if (!isLocal)
{
NetStartMeleeAttack(params.boostedAttack, params.attackIndex);
}
m_attackIndex = params.attackIndex;
m_meleeCounter = (m_meleeCounter + 1) % kMeleeCounterMax;
CHANGED_NETWORK_STATE(this, ASPECT_MELEE);
return true;
}
//------------------------------------------------------------------------
void CGameRulesHoldObjectiveBase::InsideStateChanged(SHoldEntityDetails *pDetails)
{
pDetails->m_insideCount[0] = pDetails->m_insideEntities[0].size();
pDetails->m_insideCount[1] = pDetails->m_insideEntities[1].size();
int team1Count = pDetails->m_insideCount[0];
int team2Count = pDetails->m_insideCount[1];
int oldControllingTeamId = pDetails->m_controllingTeamId;
DetermineControllingTeamId(pDetails, team1Count, team2Count);
if( oldControllingTeamId != pDetails->m_controllingTeamId )
{
OnControllingTeamChanged(pDetails, oldControllingTeamId);
}
CHANGED_NETWORK_STATE(g_pGame->GetGameRules(), HOLD_OBJECTIVE_STATE_ASPECT);
OnInsideStateChanged(pDetails);
}
//------------------------------------------------------------------------
void CVehicleMovementHelicopter::Update(const float deltaTime)
{
FUNCTION_PROFILER( GetISystem(), PROFILE_GAME );
CVehicleMovementBase::Update(deltaTime);
UpdateDamages(deltaTime);
UpdateEngine(deltaTime);
{
CryAutoCriticalSection lk(m_lock);
m_netActionSync.Read(this);
if (gEnv->bServer)
{
m_sendTimer -= deltaTime;
if (m_sendTimer<=0.f)
{
m_netActionSync.Write(this);
CHANGED_NETWORK_STATE(m_pVehicle, m_updateAspects);
m_sendTimer = m_sendTime;
}
}
}
SetSoundParam(eSID_Run, "rpm_scale", m_rpmScale);
// update animation
if(m_isEngineGoingOff)
{
if(m_enginePower > 0.0f)
{
UpdateEngine(deltaTime);
}
else
{
m_enginePower = 0.0f;
}
}
SetAnimationSpeed(eVMA_Engine, (m_enginePower / m_enginePowerMax));
}
//------------------------------------------------------------------------
void CWeapon::RequestShoot(IEntityClass* pAmmoType, const Vec3 &pos, const Vec3 &dir, const Vec3 &vel, const Vec3 &hit, float extra, int predictionHandle, bool forceExtended)
{
CActor *pActor=GetOwnerActor();
if (!gEnv->bServer && pActor && pActor->IsClient())
{
#if defined(ANTI_CHEAT)
IncShotCount(static_cast<CFireMode*>(m_fm)->GetShotIncrementAmount());
if (IsServerSpawn(pAmmoType) || forceExtended)
{
GetGameObject()->InvokeRMI(CWeapon::SvRequestShootEx(), SvRequestShootExParams(pos, dir, vel, hit, extra, predictionHandle, m_firemode), eRMI_ToServer);
}
else
{
uint32 shotId = ((((uint32)(TRUNCATE_PTR)this & 0x000fff00) << 12) + (GetShotCount() << GetShotIdCountOffset())) | pActor->GetChannelId() | (m_firemode << GetShotIdFireModeOffset());
//use bits 16 to 19 to encode the fire mode.
assert(m_firemode >= 0 && m_firemode < 16);
m_lastShotId = shotId; //A bit of a waste, but we don't want to change the interface for compatibility reasons.
//CryLog("Recording last shot ID as %u", m_lastShotId);
GetGameObject()->InvokeRMI(CWeapon::SvRequestShoot(), SvRequestShootParams(hit, shotId, m_firemode), eRMI_ToServer);
}
#else
if (IsServerSpawn(pAmmoType) || forceExtended)
GetGameObject()->InvokeRMI(CWeapon::SvRequestShootEx(), SvRequestShootExParams(pos, dir, vel, hit, extra, predictionHandle, m_firemode), eRMI_ToServer);
else
GetGameObject()->InvokeRMI(CWeapon::SvRequestShoot(), SvRequestShootParams(hit, m_firemode), eRMI_ToServer);
#endif
m_expended_ammo++;
m_fireCounter++;
}
else if (IsServer())
{
m_fireCounter++;
CHANGED_NETWORK_STATE(this, ASPECT_STREAM);
}
}
void CNetPlayerInput::Update()
{
if (gEnv->bServer && (g_pGameCVars->sv_input_timeout>0) && ((gEnv->pTimer->GetFrameStartTime()-m_lastUpdate).GetMilliSeconds()>=g_pGameCVars->sv_input_timeout))
{
m_curInput.deltaMovement.zero();
// PLAYERPREDICTION
m_curInput.sprint=false;
m_curInput.stance=(uint8)STANCE_NULL;
CHANGED_NETWORK_STATE(m_pPlayer, IPlayerInput::INPUT_ASPECT );
// ~PLAYERPREDICTION
}
// Disallow animation movement control for remotely controlled
// characters. We'll rely on the interpolation to server-controlled
// location & rotation.
if( m_pPlayer && m_pPlayer->GetAnimatedCharacter() )
{
IAnimatedCharacter* pAnimChar = m_pPlayer->GetAnimatedCharacter();
pAnimChar->SetMovementControlMethods( eMCM_Entity, eMCM_Entity );
pAnimChar->UseAnimationMovementForEntity( false, false, false );
}
}
