void ASWeapon::DetermineWeaponState()
{
EWeaponState NewState = EWeaponState::Idle;
if (bIsEquipped)
{
if (bPendingReload)
{
if (CanReload())
{
NewState = EWeaponState::Reloading;
}
else
{
NewState = CurrentState;
}
}
else if (!bPendingReload && bWantsToFire && CanFire())
{
NewState = EWeaponState::Firing;
}
}
else if (bPendingEquip)
{
NewState = EWeaponState::Equipping;
}
SetWeaponState(NewState);
}
void AShooterWeapon::DetermineWeaponState()
{
EWeaponState::Type NewState = EWeaponState::Idle;
if (bIsEquipped)
{
if( bPendingReload )
{
if( CanReload() == false )
{
NewState = CurrentState;
}
else
{
NewState = EWeaponState::Reloading;
}
}
else if ( (bPendingReload == false ) && ( bWantsToFire == true ) && ( CanFire() == true ))
{
NewState = EWeaponState::Firing;
}
}
else if (bPendingEquip)
{
NewState = EWeaponState::Equipping;
}
SetWeaponState(NewState);
}
//------------------------------------------------------------------------
void CDetonate::StartFire()
{
if (CanFire(false))
{
CActor *pOwner=m_pWeapon->GetOwnerActor();
CCCPOINT(DetonateFireMode_StartFireOK);
m_pWeapon->RequireUpdate(eIUS_FireMode);
m_detonationTimer = 0.1f;
m_pWeapon->PlayAction(GetFragmentIds().fire);
m_pWeapon->RequestDetonate();
}
else
{
#if !defined(_RELEASE)
IFireMode* pFM = m_pWeapon->GetFireMode(m_pWeapon->GetCurrentFireMode());
EntityId projectileId = pFM ? pFM->GetProjectileId() : 0;
IEntity * projectile = gEnv->pEntitySystem->GetEntity(projectileId);
CryLog ("[Detonate] Failure to detonate %s '%s' (timer = %.4f, can detonate = %s, fire mode = '%s') projectile = %u (%s '%s')",
m_pWeapon->GetEntity()->GetClass()->GetName(),
m_pWeapon->GetEntity()->GetName(),
m_detonationTimer,
m_canDetonate ? "TRUE" : "FALSE",
pFM ? pFM->GetName() : "NONE",
projectileId,
projectile ? projectile->GetClass()->GetName() : "NONE",
projectile ? projectile->GetName() : "N/A");
#endif
CCCPOINT_IF(m_detonationTimer > 0.0f, DetonateFireMode_CannotFire_TimerNotReachedZero);
CCCPOINT(DetonateFireMode_CannotFire);
}
}
void UMWBotWeaponComponent::Fire()
{
if (!CanFire())
{
return;
}
// cast a line
FHitResult hit;
FCollisionQueryParams traceParams;
traceParams.AddIgnoredActor(GetOwner());
const int32 randSeed = FMath::Rand();
FRandomStream randStream(randSeed);
const FVector traceStart = GetComponentLocation();
const FVector aimDir = GetComponentRotation().Vector();
const FVector shotDir = randStream.VRandCone(aimDir, FMath::DegreesToRadians(Spread));
const FVector traceEnd = traceStart + shotDir * 1e5;
GetWorld()->LineTraceSingle(hit, traceStart, traceEnd, ECollisionChannel::ECC_Visibility, traceParams);
ProcessHit(hit);
// temporary draw
if (hit.bBlockingHit)
{
DrawDebugLine(GetWorld(), traceStart, hit.ImpactPoint, FColor::Red, false, -1.f, 0, 10);
}
else
{
DrawDebugLine(GetWorld(), traceStart, traceEnd, FColor::Red, false, -1.f, 0, 10);
}
}
//------------------------------------------------------------------------
void CAutomatic::Update(float frameTime, uint32 frameId)
{
CSingle::Update(frameTime, frameId);
if(m_firing && CanFire(false))
m_firing = Shoot(true);
}
//------------------------------------------------------------------------
void CPlant::StartFire()
{
CActor* pOwner = m_pWeapon->GetOwnerActor();
if (pOwner && pOwner->IsClient() && !CanFire(true))
{
return;
}
CPlayer *ownerPlayer = m_pWeapon->GetOwnerPlayer();
if (ownerPlayer)
{
ownerPlayer->StateMachineHandleEventMovement( PLAYER_EVENT_FORCEEXITSLIDE );
}
m_pWeapon->RequireUpdate(eIUS_FireMode);
m_planting = true;
m_pWeapon->SetBusy(true);
m_pWeapon->PlayAction(GetFragmentIds().intoPlant, 0,false,CItem::eIPAF_Default);
m_pWeapon->GetScheduler()->TimerAction(m_pWeapon->GetCurrentAnimationTime(eIGS_Owner), CSchedulerAction<StartPlantAction>::Create(this), false);
m_pWeapon->RequestStartFire();
}
void AAWeapon::HandleFiring()
{
if (CurrentAmmoInClip > 0 && CanFire())
{
if (GetNetMode() != NM_DedicatedServer)
{
SimulateWeaponFire();
}
if (MyPawn && MyPawn->IsLocallyControlled())
{
FireWeapon();
UseAmmo();
BurstCounter++;
}
}
else if (CanReload())
{
StartReload();
}
else if (MyPawn && MyPawn->IsLocallyControlled())
{
if (GetCurrentAmmo() == 0 && !bRefiring)
{
PlayWeaponSound(OutOfAmmoSound);
}
/* Reload after firing last round */
if (CurrentAmmoInClip <= 0 && CanReload())
{
StartReload();
}
/* Stop weapon fire FX, but stay in firing state */
if (BurstCounter > 0)
{
OnBurstFinished();
}
}
if (MyPawn && MyPawn->IsLocallyControlled())
{
if (Role < ROLE_Authority)
{
ServerHandleFiring();
}
/* Retrigger HandleFiring on a delay for automatic weapons */
bRefiring = (CurrentState == EWeaponState::Firing && TimeBetweenShots > 0.0f);
if (bRefiring)
{
GetWorldTimerManager().SetTimer(TimerHandle_HandleFiring, this, &AAWeapon::HandleFiring, TimeBetweenShots, false);
}
}
LastFireTime = GetWorld()->GetTimeSeconds();
}
//------------------------------------------------------------------------
void CDetonate::StartFire()
{
if (CanFire(false))
{
m_pWeapon->RequireUpdate(eIUS_FireMode);
m_detonationTimer = 0.1f;
m_pWeapon->PlayAction(m_pShared->actions.fire.c_str());
}
}
void AWeapon::HandleFiring()
{
if ((CurrentAmmoInClip > 0 || HasInfiniteClip() || HasInfiniteAmmo()) && CanFire())
{
if (GetNetMode() != NM_DedicatedServer)
{
SimulateWeaponFire();
}
if (MyPawn && MyPawn->IsLocallyControlled())
{
FireWeapon();
UseAmmo();
// update firing FX on remote clients if function was called on server
BurstCounter++;
}
}
else if (CanReload())
{
StartReload();
}
else if (MyPawn && MyPawn->IsLocallyControlled())
{
// stop weapon fire FX, but stay in Firing state
if (BurstCounter > 0)
{
OnBurstFinished();
}
}
if (MyPawn && MyPawn->IsLocallyControlled())
{
// local client will notify server
if (Role < ROLE_Authority)
{
ServerHandleFiring();
}
// reload after firing last round
if (CurrentAmmoInClip <= 0 && CanReload())
{
StartReload();
}
// setup refire timer
bRefiring = (CurrentState == EWeaponState::Firing && WeaponConfig.TimeBetweenShots > 0.0f);
if (bRefiring)
{
GetWorldTimerManager().SetTimer(TimerHandle_HandleFiring, this, &AWeapon::HandleFiring, WeaponConfig.TimeBetweenShots, false);
}
}
LastFireTime = GetWorld()->GetTimeSeconds();
}
//-------------------------------------------------------------------------------------------------
// Purpose: Checks if we our m_flNextFireTime tells us to start point-blanking
//-------------------------------------------------------------------------------------------------
bool CSDKBot::ThinkCheckPointBlank() {
if (CanFire() && m_flNextFireTime < gpGlobals->curtime
&& m_PlayerSearchInfo.CloseEnemy()) {
ScheduleThinker(&BotThinkers::PointBlank, 0.05f);
return false;
} else if (m_flNextFireTime < gpGlobals->curtime)
m_flNextFireTime = FLT_MAX;
return true;
}
//------------------------------------------------------------------------
void CVehicleWeapon::StartFire()
{
if (!CheckWaterLevel())
return;
if(!CanFire())
return;
CWeapon::StartFire();
}
//-------------------------------------------------------------------------------------------------
// Purpose: Simulates close-quarters combat
//-------------------------------------------------------------------------------------------------
bool CSDKBot::ThinkMelee_Begin() {
//CheckSwitchWeapon(); //This is instead handled farther below
SendBotVcommContext(DEFAULT);
SetUpdateFlags(false);
//m_curCmd.buttons |= IN_FORWARD;
m_flNextStrafeTime = gpGlobals->curtime + RandomFloat(0.5f, 1.0f);
bool canMelee = CanMelee();
if (CanFire()) {
//If we can't melee, fire as soon as possible
if (!canMelee) {
m_flNextFireTime = -FLT_MAX;
}
//Otherwise, possibly fire
else {
float random = RandomFloat();
if (m_pPlayer->GetHealth() < 70)
random += 0.3;
if (random > 0.5) {
m_flNextFireTime = gpGlobals->curtime + RandomFloat(0.5f, 1.2f);
}
}
}
//If we can't fire and can't melee, switch weapons
else if (!canMelee){
m_pPlayer->Weapon_Switch(m_pPlayer->Weapon_FindMeleeWeapon());
UpdateWeaponInfo();
}
float randomStrafe = bot_randfloat();
if (randomStrafe < 0.45f) {
m_curCmd.buttons |= IN_LEFT;
m_curCmd.buttons &= ~IN_RIGHT;
} else if (randomStrafe < 0.9f) {
m_curCmd.buttons &= ~IN_LEFT;
m_curCmd.buttons |= IN_RIGHT;
} else {
m_curCmd.buttons &= ~IN_LEFT;
m_curCmd.buttons &= ~IN_RIGHT;
}
float randomForward = bot_randfloat();
//don't move forward if we're too close
if ( m_PlayerSearchInfo.CloseEnemyDist() < m_flMeleeRange) {
m_curCmd.buttons &= ~IN_FORWARD;
m_curCmd.buttons |= IN_BACK;
} else if (randomForward < 0.5f){
m_curCmd.buttons |= IN_FORWARD;
m_curCmd.buttons &= ~IN_BACK;
} else {
m_curCmd.buttons &= ~IN_FORWARD;
m_curCmd.buttons &= ~IN_BACK;
}
return true;
}
void CJaw::UpdatePendingShot()
{
if (m_firePending && CanFire() && IsZoomed())
{
m_controllingRocket = true;
m_firePending = false;
HideRocket();
BaseClass::StartFire();
AutoZoomOut();
}
}
//-------------------------------------------------------------------------------------------------
// Purpose: Long-range combat
//-------------------------------------------------------------------------------------------------
bool CSDKBot::ThinkLongRange_Begin() {
SendBotVcommContext(ADVANCE);
SetUpdateFlags(true);
if (CanFire()) {
float random = bot_randfloat();
if (random < m_pDifficult->m_flLongRangeFire) {
m_flNextFireTime = gpGlobals->curtime + RandomFloat(0.5f, 4.2f);
}
}
return true;
}
void ASWeapon::ServerHandleFiring_Implementation()
{
const bool bShouldUpdateAmmo = CanFire();
HandleFiring();
if (bShouldUpdateAmmo)
{
// Update firing FX on remote clients
BurstCounter++;
}
}
//------------------------------------------------------------------------
void CRapid::StartFire()
{
if (m_pWeapon->IsBusy() || !CanFire(true))
{
//Clip empty sound
if(!CanFire(true) && !m_reloading)
{
int ammoCount = m_pWeapon->GetAmmoCount(m_fireParams->fireparams.ammo_type_class);
if (GetClipSize()==0)
ammoCount = m_pWeapon->GetInventoryAmmoCount(m_fireParams->fireparams.ammo_type_class);
if(ammoCount<=0)
{
m_pWeapon->PlayAction(GetFragmentIds().empty_clip);
m_pWeapon->OnFireWhenOutOfAmmo();
}
}
return;
}
m_rapidFlags &= ~eRapidFlag_netShooting;
if ((m_rapidFlags & (eRapidFlag_decelerating | eRapidFlag_accelerating)) == 0)
{
m_pWeapon->EnableUpdate(true, eIUS_FireMode);
}
//SpinUpEffect(true);
Accelerate(m_fireParams->rapidparams.acceleration);
m_rapidFlags |= eRapidFlag_startedFiring;
m_firstFire = true;
m_startFiringTime = gEnv->pTimer->GetAsyncTime();
m_muzzleEffect.StartFire(this);
m_pWeapon->RequestStartFire();
}
bool CSDKBot::ThinkPointBlank() {
CBasePlayer* pEnemy = m_PlayerSearchInfo.CloseEnemy();
if (pEnemy) {
LookAt(pEnemy->Weapon_ShootPosition() + downToChest * bot_randfloat(0.5, 2.0), 0.35f + m_pDifficult->m_flAimTurnLerp, m_pDifficult->m_flRandomAim / 6);
}
if (CanFire() && m_flNextFireTime < gpGlobals->curtime && !IsAimingAtTeammate(m_PlayerSearchInfo.CloseEnemyDist())) {
m_curCmd.buttons |= IN_ATTACK;
//ScheduleThinker(m_pPrevThinker, 0);
//return false;
}
return true;
}
void AAWeapon::ServerHandleFiring_Implementation()
{
const bool bShouldUpdateAmmo = (CurrentAmmoInClip > 0 && CanFire());
HandleFiring();
if (bShouldUpdateAmmo)
{
UseAmmo();
BurstCounter++;
}
}
//------------------------------------------------------------------------
void CRapid::StartFire()
{
if (m_pWeapon->IsBusy() || !CanFire(true))
{
//Clip empty sound
if(!CanFire(true) && !m_reloading)
{
int ammoCount = m_pWeapon->GetAmmoCount(m_pShared->fireparams.ammo_type_class);
if (m_pShared->fireparams.clip_size==0)
ammoCount = m_pWeapon->GetInventoryAmmoCount(m_pShared->fireparams.ammo_type_class);
if(ammoCount<=0)
{
m_pWeapon->PlayAction(m_pShared->actions.empty_clip);
//Auto reload
m_pWeapon->Reload();
}
}
return;
}
else if(m_pWeapon->IsWeaponLowered())
{
m_pWeapon->PlayAction(m_pShared->actions.null_fire);
return;
}
m_netshooting = false;
m_pWeapon->EnableUpdate(true, eIUS_FireMode);
//SpinUpEffect(true);
Accelerate(m_pShared->rapidparams.acceleration);
m_startedToFire = true;
m_pWeapon->RequestStartFire();
}
void AMagicBattleSoccerWeapon::DetermineWeaponState()
{
EWeaponState NewState = EWeaponState::Idle;
if (nullptr != MyPawn && bIsEquipped)
{
if (bWantsToFire && CanFire())
{
NewState = EWeaponState::Firing;
}
}
SetWeaponState(NewState);
}
//------------------------------------------------------------------------
void CAutomatic::Update(float frameTime, uint32 frameId)
{
BaseClass::Update(frameTime, frameId);
if (m_firing && CanFire(false))
{
m_firing = Shoot(true, m_fireParams->fireparams.autoReload);
if(!m_firing)
{
StopFire();
}
}
}
void AShooterWeapon::ServerHandleFiring_Implementation()
{
const bool bShouldUpdateAmmo = (CurrentAmmoInClip > 0 && CanFire());
HandleFiring();
if (bShouldUpdateAmmo)
{
// update ammo
UseAmmo();
// update firing FX on remote clients
BurstCounter++;
}
}
void CAutomaticShotgun::Update(float frameTime, uint32 frameId)
{
CShotgun::Update(frameTime, frameId);
if (m_firing)
{
m_rapidFireCountdown -= frameTime;
if (m_rapidFireCountdown < 0.0f && CanFire(true))
{
bool shot = Shoot(true, true);
if (shot)
m_rapidFireCountdown += m_next_shot_dt;
}
}
}
void CJaw::StartFire()
{
if (!CanFire())
return;
CActor* pOwner = GetOwnerActor();
#if (USE_DEDICATED_INPUT)
if (!pOwner || (!pOwner->IsPlayer() || (gEnv->bMultiplayer && strcmp(pOwner->GetEntityClassName(), "DummyPlayer") == 0)))
#else
if (!pOwner || !pOwner->IsPlayer())
#endif
{
BaseClass::StartFire();
return;
}
if (m_controllingRocket)
return;
CPlayer *ownerPlayer = GetOwnerPlayer();
if (ownerPlayer)
{
if(ownerPlayer->IsClient() && ownerPlayer->IsWeaponUnderWater())
{
return;
}
ownerPlayer->StateMachineHandleEventMovement( PLAYER_EVENT_FORCEEXITSLIDE );
}
if (!m_firePending && m_zm && g_pGameCVars->cl_zoomToggle > 0)
{
m_zoomAlreadyToggled = (m_zm->IsZoomingIn() || m_zm->IsZoomed());
}
else
{
m_zoomAlreadyToggled = false;
}
if(!IsZoomingInOrOut())
{
if (m_zm)
m_zm->ZoomIn();
}
m_fireTriggerDown = true;
m_firePending = true;
}
void WeaponBase::Fire(glm::vec3 fireOrigin, glm::vec3 fireDirection)
{
fireAttempt = true;
if (CanFire())
{
storedAmmo -= GetRequiredAmmoToFire();
firingTime = fireRateInSeconds;
coolingTime = cooldownInSeconds;
FireInternal(fireOrigin, fireDirection);
}
else if (continualFire && firingTime > 0.0f)
{
// Continue fire weapons we can fire until firing time == 0, at which point we have to wait for the cooldown.
FireInternal(fireOrigin, fireDirection);
}
}
//------------------------------------------------------------------------
void CWorkOnTarget::StartFire()
{
if(m_pWeapon->IsBusy() || !CanFire(false) || !CanWork())
return;
m_firing=true;
m_pWeapon->SetBusy(true);
m_soundId=m_pWeapon->PlayAction(m_workactions.work.c_str(), 0, true, CItem::eIPAF_Default|CItem::eIPAF_CleanBlending|CItem::eIPAF_SoundStartPaused);
m_pWeapon->SetDefaultIdleAnimation(eIGS_FirstPerson, m_workactions.work.c_str());
m_pWeapon->EnableUpdate(true, eIUS_FireMode);
m_delayTimer=m_workparams.delay;
if(!m_pWeapon->IsServer())
m_pWeapon->RequestStartFire();
}
void ASWeapon::DetermineWeaponState()
{
EWeaponState NewState = EWeaponState::Idle;
if (bIsEquipped)
{
if (bWantsToFire && CanFire())
{
NewState = EWeaponState::Firing;
}
}
else if (bPendingEquip)
{
NewState = EWeaponState::Equipping;
}
SetWeaponState(NewState);
}
//------------------------------------------------------------------------
void CThrow::StartFire()
{
m_netfiring = false;
if (CanFire(true) && !m_firing && !m_throwing && !m_pulling)
{
m_firing = true;
m_pulling = true;
m_throwing = false;
m_thrown = false;
m_pWeapon->SetBusy(true);
m_pWeapon->PlayAction(m_pShared->throwactions.pull);
m_pWeapon->GetScheduler()->TimerAction(m_pWeapon->GetCurrentAnimationTime( eIGS_FirstPerson) + 1, CSchedulerAction<StartThrowAction>::Create(this), false);
m_pWeapon->SetDefaultIdleAnimation( eIGS_FirstPerson, m_pShared->throwactions.hold);
m_hold_timer = m_pShared->throwparams.hold_duration;
m_pWeapon->RequestStartFire();
m_pWeapon->RequireUpdate(eIUS_FireMode);
}
}
void AMagicBattleSoccerWeapon::HandleFiring()
{
if (CanFire())
{
if (MyPawn && MyPawn->IsLocallyControlled())
{
FireWeapon();
}
}
if (nullptr != MyPawn && MyPawn->IsLocallyControlled())
{
// local client will notify server
if (Role < ROLE_Authority)
{
ServerHandleFiring();
}
// Make the player aim in the direction they're firing if they're not running
AMagicBattleSoccerPlayerController* const PlayerController = Instigator ? Cast<AMagicBattleSoccerPlayerController>(Instigator->Controller) : nullptr;
if (nullptr != PlayerController
&& nullptr != PlayerController->GetPawn()
&& nullptr != PlayerController->GetPawn()->GetMovementComponent()
&& PlayerController->GetPawn()->GetMovementComponent()->Velocity.Size() < 0.001f)
{
// We can't aim immediately because that could put the camera out of sync with the pawn. Just assign ourselves to the controller and it
// will take care of things in the next Tick().
PlayerController->bFaceMouseCursorInTick = true;
}
// setup refire timer
bRefiring = (LocalState == EWeaponState::Firing && WeaponConfig.TimeBetweenShots > 0.0f && WeaponConfig.RepeatingFire);
if (bRefiring)
{
// Start a timer to handle repeating firing
GetWorldTimerManager().SetTimer(TimerHandle_HandleFiringTimer, this, &AMagicBattleSoccerWeapon::HandleFiring, WeaponConfig.TimeBetweenShots, false);
}
}
LastFireTime = GetWorld()->GetTimeSeconds();
}
void ASWeapon::HandleFiring()
{
if (CanFire())
{
if (GetNetMode() != NM_DedicatedServer)
{
SimulateWeaponFire();
}
if (MyPawn && MyPawn->IsLocallyControlled())
{
FireWeapon();
// TODO: Consume Ammo
// Update firing FX on remote clients if this is called on server
// Cause it is replicated value on server.
BurstCounter++;
}
}
// TODO: End repeat fire if ammo runs dry
if (MyPawn && MyPawn->IsLocallyControlled())
{
if (Role < ROLE_Authority)
{
ServerHanleFiring();
}
// TODO: if weapon is automatic firing rifle -> Setup refiring timer. (calls HandleFiring())
bRefiring = (CurrentState == EWeaponState::Firing && TimeBetweenShots > 0.0f);
if (bRefiring)
{
GetWorldTimerManager().SetTimer(HandleFiringTimerHandle, this, &ASWeapon::HandleFiring, TimeBetweenShots, false);
}
}
LastFireTime = GetWorld()->GetTimeSeconds();
}