protected void UpdateOrientationAttenuation(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
var orientation = attackProxy.Orientation;
var punchYaw = orientation.AccPunchYaw;
var punchPitch = orientation.AccPunchPitch;
var frameSec = cmd.UserCmd.FrameInterval / 1000f;
//获取向量长度
var puntchLength = Mathf.Sqrt(punchYaw * punchYaw + punchPitch * punchPitch);
if (puntchLength > 0)
{
punchYaw = punchYaw / puntchLength;
punchPitch = punchPitch / puntchLength;
puntchLength = UpdateLen(attackProxy, puntchLength, frameSec);
//UpdateLen: AccPunchYaw =>AccPunchYaw
orientation.AccPunchYaw = punchYaw * puntchLength;
orientation.AccPunchPitch = punchPitch * puntchLength;
var factor = GePuntchFallbackFactor(attackProxy.Owner);
//GePuntchFallbackFactor : AccPunchYaw => AccPunchPitch
orientation.AccPunchYawValue = orientation.AccPunchYaw * factor;
orientation.AccPunchPitchValue = orientation.AccPunchPitch * factor;
}
}
private void CallOnIdle(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
foreach (var fireIdle in _idles)
{
fireIdle.OnIdle(attackProxy, cmd);
}
}
private void CallAfterFires(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
foreach (var afterfire in _afterFireProcessors)
{
afterfire.OnAfterFire(attackProxy, cmd);
}
}
private void CallBeforeFires(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
foreach (var beforeFire in _beforeFireProcessors)
{
beforeFire.OnBeforeFire(attackProxy, cmd);
}
}
private void CallOnFrame(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
foreach (var frame in _frames)
{
frame.OnFrame(attackProxy, cmd);
}
}
public void OnAfterFire(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
if (attackProxy.BasicComponent.RealFireModel != (int)EFireMode.Burst)
{
return;
}
var runTimeComponent = attackProxy.RuntimeComponent;
runTimeComponent.NeedAutoBurstShoot = false;
var config = attackProxy.WeaponConfigAssy.S_DefaultFireModeLogicCfg;
runTimeComponent.BurstShootCount += 1;
float intervalFactor = 1 - attackProxy.GetAttachedAttributeByType(WeaponAttributeType.AttackInterval) / 100;
if (runTimeComponent.BurstShootCount < config.BurstCount)
{
runTimeComponent.NextAttackTimestamp = cmd.UserCmd.RenderTime + Mathf.CeilToInt(config.BurstAttackInnerInterval * intervalFactor);
runTimeComponent.NeedAutoBurstShoot = true;
runTimeComponent.IsPrevCmdFire = true;
}
else
{
runTimeComponent.NextAttackTimestamp = cmd.UserCmd.RenderTime + Mathf.CeilToInt(config.BurstAttackInterval * intervalFactor);
runTimeComponent.BurstShootCount = 0;
}
if (attackProxy.BasicComponent.Bullet == 0)
{
runTimeComponent.BurstShootCount = 0;
runTimeComponent.NeedAutoBurstShoot = false;
}
}
protected override void Update(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
var config = attackProxy.WeaponConfigAssy.S_PistolSpreadLogicCfg;
float spreadScaleFactor = FireSpreadProvider.GetSpreadScaleFactor(config, attackProxy);
FireSpreadFormula.ApplyPistolFinalSpread(spreadScaleFactor, config.SpreadScale, attackProxy.RuntimeComponent);
}
protected override void DoIdle(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
//null->Fire->SpecialFireHold(1)->SpecialFireEnd->null
if (cmd.FiltedInput(EPlayerInput.IsPullboltInterrupt))
{//当前pullBolting被限制，不执行
attackProxy.InterruptPullBolt();
return;
}
var state = attackProxy.CharacterState.GetActionState();
//正常开火拉栓
if (state == ActionInConfig.SpecialFireHold)
{
logger.Info("Normal pullbolt");
attackProxy.AudioController.PlayPullBoltAudio(attackProxy.WeaponConfigAssy.S_Id);
attackProxy.CharacterState.SpecialFireEnd();
attackProxy.RuntimeComponent.FinishPullBolt();
return;
}
if (state == ActionInConfig.Null && attackProxy.BasicComponent.Bullet > 0)
{
//只拉栓逻辑
if (attackProxy.RuntimeComponent.IsPullboltInterrupt)
{
logger.Info("Interrupt pullbolt");
attackProxy.RuntimeComponent.FinishPullBolt();
attackProxy.AudioController.PlayPullBoltAudio(attackProxy.WeaponConfigAssy.S_Id);
attackProxy.CharacterState.SpecialFireEnd();
}
// var needActionDeal = SingletonManager.Get<WeaponResourceConfigManager>()
// .NeedActionDeal(attackProxy.WeaponConfigAssy.S_Id, ActionDealEnum.Reload);
}
}
public virtual bool IsCanFire(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
if (cmd.UserCmd.RenderTime < attackProxy.RuntimeComponent.NextAttackTimestamp)
{
return(false);
}
if (attackProxy.BasicComponent.Bullet <= 0)
{
attackProxy.Owner.ShowTip(ETipType.FireWithNoBullet);
if (cmd.FiltedInput(EPlayerInput.IsLeftAttack))
{
attackProxy.AudioController.PlayEmptyFireAudio();
}
return(false);
}
EFireMode currentMode = (EFireMode)attackProxy.BasicComponent.RealFireModel;
switch (currentMode)
{
case EFireMode.Manual:
return(!attackProxy.RuntimeComponent.IsPrevCmdFire);
case EFireMode.Auto:
return(true);
case EFireMode.Burst:
return(!attackProxy.RuntimeComponent.IsPrevCmdFire || attackProxy.RuntimeComponent.NeedAutoBurstShoot);
default:
return(false);
}
}
public void OnIdle(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
if (!cmd.IsFire)
{
attackProxy.AudioController.StopFireTrigger();
DoIdle(attackProxy, cmd);
}
}
//以当前0.5X+10速度衰减
public virtual float UpdateLen(WeaponAttackProxy attackProxy, float len, float frameSec)
{
var r = len;
r -= (10f + r * 0.5f) * frameSec;
r = Mathf.Max(r, 0f);
return(r);
}
public void OnFrame(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
if (!cmd.IsFire)
{
attackProxy.RuntimeComponent.IsPrevCmdFire = false;
attackProxy.AudioController.StopFireTrigger();
}
}
public override void OnAfterFire(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
var config = attackProxy.WeaponConfigAssy.SRifleShakeCfg;
var shakeGroup = FireShakeProvider.GetShakeGroup(config, attackProxy.Owner);
var shakeInfo = FireShakeProvider.GetShakeInfo(config, attackProxy.Owner, shakeGroup);
CalcBaseShake(attackProxy, cmd.UserCmd.Seq, shakeInfo);
}
public override bool IsCanFire(WeaponAttackProxy attackProxy, WeaponSideCmd weaponCmd)
{
if (base.IsCanFire(attackProxy, weaponCmd))
{
return(attackProxy.RuntimeComponent.PullBoltFinish);
}
return(false);
}
public override float UpdateLen(WeaponAttackProxy attackProxy, float len, float frameTime)
{
var r = len;
r -= (attackProxy.WeaponConfigAssy.SRifleShakeCfg.FixedDecayFactor +
r * attackProxy.WeaponConfigAssy.SRifleShakeCfg.LenDecayFactor) * frameTime;
r = Mathf.Max(r, 0f);
return(r);
}
public override void OnAfterFire(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
var config = attackProxy.WeaponConfigAssy.SFixedShakeCfg;
if (null == config)
{
return;
}
attackProxy.Orientation.AccPunchPitch += config.PunchPitch;
attackProxy.Orientation.AccPunchPitchValue += config.PunchPitch * config.PunchOffsetFactor;
}
public void OnIdle(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
if (attackProxy.RuntimeComponent.ContinuesShootCount == 0)
{
var config = attackProxy.WeaponConfigAssy.S_PistolAccuracyLogicCfg;
if (config != null)
{
attackProxy.RuntimeComponent.Accuracy = config.InitAccuracy;
}
}
}
protected override void Update(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
// var appearance = controller.RelatedAppearence;
// var weaponObject = appearance.IsFirstPerson
// ? appearance.GetWeaponP1InHand()
// : appearance.GetWeaponP3InHand();
// DebugUtil.MyLog(weaponObject.transform.position.ToString("f4"));
RifleSpreadLogicConfig config = attackProxy.WeaponConfigAssy.S_RifleSpreadLogicCfg;
float spreadScaleFactor = FireSpreadProvider.GetSpreadScaleFactor(config, attackProxy);
FireSpreadFormula.ApplyRifleFinalSpread(spreadScaleFactor, config.SpreadScale, attackProxy.RuntimeComponent);
}
public override void OnAfterFire(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
attackProxy.RuntimeComponent.StartPullBolt();
if (attackProxy.BasicComponent.Bullet > 0)
{
var needActionDeal = SingletonManager.Get <WeaponResourceConfigManager>()
.NeedActionDeal(attackProxy.WeaponConfigAssy.S_Id, ActionDealEnum.Reload);
SpecialFireAppearance(attackProxy, needActionDeal);
}
else
{
base.OnAfterFire(attackProxy, cmd);
}
}
public virtual void OnAfterFire(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
if (attackProxy.CharacterState != null)
{
if (attackProxy.IsAiming)
{
attackProxy.CharacterState.SightsFire();
}
else
{
attackProxy.CharacterState.Fire();
}
}
}
public void OnBeforeFire(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
if (attackProxy.WeaponConfigAssy.S_RifleFireCounterCfg == null)
{
return;
}
var runTimeComponent = attackProxy.RuntimeComponent;
// runTimeComponent.NeedReduceContinuesShootCD = true;
runTimeComponent.ContinuesShootCount = Mathf.Min(++runTimeComponent.ContinuesShootCount,
attackProxy.WeaponConfigAssy.S_RifleFireCounterCfg.MaxCount);
runTimeComponent.ContinuesShootReduceTimestamp =
cmd.UserCmd.RenderTime + attackProxy.WeaponConfigAssy.S_RifleFireCounterCfg.DecreaseInitInterval;
}
/// <summary>
/// TargetPunchPitchDelta => AccPunchYaw,AccPunchYawValue
/// </summary>
/// <param name="agent"></param>
/// <param name="cmd"></param>
public override void OnFrame(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
ShakeGroup shakeGroup = FireShakeProvider.GetShakeGroup(attackProxy.WeaponConfigAssy.SRifleShakeCfg, attackProxy.Owner);
var runTimeComponent = attackProxy.RuntimeComponent;
//int frameInterval = cmd.UserCmd.FrameInterval;
var orient = attackProxy.Orientation;
//后坐力生效时间
var deltaTime = Mathf.Min(cmd.UserCmd.FrameInterval, cmd.UserCmd.RenderTime - runTimeComponent.LastRenderTimestamp);
if (runTimeComponent.PunchDecayLeftInterval > 0)
{
float totalInterval = FireShakeProvider.GetDecayInterval(attackProxy.WeaponConfigAssy);
float lastInterval = runTimeComponent.PunchDecayLeftInterval;
runTimeComponent.PunchDecayLeftInterval -= deltaTime;
float newInterval = runTimeComponent.PunchDecayLeftInterval;
var lastPunchPitch = FireShakeFormula.EaseOutCubic(0, runTimeComponent.TargetPunchPitchDelta,
(totalInterval - lastInterval) / totalInterval);
var newPunchPitch = FireShakeFormula.EaseOutCubic(0, runTimeComponent.TargetPunchPitchDelta,
(totalInterval - newInterval) / totalInterval);
orient.AccPunchPitch += newPunchPitch - lastPunchPitch;
orient.AccPunchPitchValue = orient.AccPunchPitch * shakeGroup.VPunchOffsetFactor;
orient.AccPunchYaw += runTimeComponent.PunchYawSpeed * deltaTime;
orient.AccPunchYawValue = orient.AccPunchYaw * shakeGroup.HPunchOffsetFactor;
if (GlobalConst.EnableWeaponLog)
{
DebugUtil.MyLog(("orient.AccPunchPitch:" + orient.AccPunchPitch));
}
}
else
{
UpdateOrientationAttenuation(attackProxy, cmd);
}
if (attackProxy.WeaponConfigAssy.S_FireRollCfg != null && runTimeComponent.CameraRotationInterval > 0)
{
runTimeComponent.CameraRotationInterval -= deltaTime;
orient.FireRoll += runTimeComponent.CameraRotationSpeed * deltaTime;
}
else
{
RecoverFireRoll(attackProxy, cmd);
}
base.OnFrame(attackProxy, cmd);
}
public void OnAfterFire(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
if ((EFireMode)attackProxy.BasicComponent.RealFireModel == EFireMode.Burst)
{
return;
}
var runtimeDataComponent = attackProxy.RuntimeComponent;
runtimeDataComponent.IsPrevCmdFire = true;
float intervalFactor = 1 - attackProxy.GetAttachedAttributeByType(WeaponAttributeType.AttackInterval) / 100;
runtimeDataComponent.NextAttackTimestamp = cmd.UserCmd.RenderTime + Mathf.CeilToInt(attackProxy.WeaponConfigAssy.S_CommonFireCfg.AttackInterval * intervalFactor);
runtimeDataComponent.NeedAutoBurstShoot = false;
// runtimeDataComponent.ContinuesShootCount = 0;
runtimeDataComponent.LastAttackTimestamp = cmd.UserCmd.RenderTime;
}
public void OnBeforeFire(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
var runTimeComponent = attackProxy.RuntimeComponent;
if (runTimeComponent.LastAttackTimestamp == 0)
{
}
else
{
var config = attackProxy.WeaponConfigAssy.S_PistolAccuracyLogicCfg;
if (config == null)
{
return;
}
runTimeComponent.Accuracy = AccuracyFormula.GetPistolAccuracy(cmd.UserCmd.RenderTime - runTimeComponent.LastAttackTimestamp,
config.AccuracyFactor, config.MinAccuracy, config.MaxAccuracy);
}
}
public void OnIdle(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
if (attackProxy.WeaponConfigAssy.S_RifleFireCounterCfg == null)
{
return;
}
if (attackProxy.RuntimeComponent.ContinuesShootCount < 1)
{
return;
}
if (attackProxy.RuntimeComponent.ContinuesShootReduceTimestamp < cmd.UserCmd.RenderTime)
{
// DebugUtil.MyLog("Count -- ||DecreaseStepInterval:"+heldAgent.RifleFireCounterCfg.DecreaseStepInterval+"||"+heldAgent.RifleFireCounterCfg.DecreaseStepInterval);
attackProxy.RuntimeComponent.ContinuesShootReduceTimestamp = cmd.UserCmd.RenderTime +
attackProxy.WeaponConfigAssy.S_RifleFireCounterCfg.DecreaseStepInterval;
--attackProxy.RuntimeComponent.ContinuesShootCount;
}
}
private void UpdateAccurcy(WeaponAttackProxy attackProxy)
{
var config = attackProxy.WeaponConfigAssy.S_BaseAccuracyLogicCfg;
if (config == null)
{
return;
}
int accuracyDivisor = config.AccuracyDivisor; //除数因子
if (accuracyDivisor != -1)
{
attackProxy.RuntimeComponent.Accuracy = AccuracyFormula.GetCommonAccuracy(config.MaxInaccuracy, attackProxy.RuntimeComponent.ContinuesShootCount,
config.AccuracyDivisor, config.AccuracyOffset);
}
else
{
attackProxy.RuntimeComponent.Accuracy = 0;
}
}
protected void RecoverFireRoll(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
var rotateYaw = attackProxy.Orientation.FireRoll;
if (rotateYaw != 0)
{
if (attackProxy.WeaponConfigAssy.S_FireRollCfg == null)
{
rotateYaw = 0;
}
else
{
var rotatePos = rotateYaw >= 0;
rotateYaw -= rotateYaw * cmd.UserCmd.FrameInterval / attackProxy.WeaponConfigAssy.S_FireRollCfg.FireRollBackTime;
if ((rotatePos && rotateYaw < 0) || (!rotatePos && rotateYaw > 0))
{
rotateYaw = 0;
}
}
attackProxy.Orientation.FireRoll = rotateYaw;
}
}
protected void SpecialFireAppearance(WeaponAttackProxy attackProxy, bool needActionDeal)
{
var relatedCharState = attackProxy.CharacterState;
var relatedAppearance = attackProxy.Appearence;
if (relatedCharState == null)
{
return;
}
if (attackProxy.CanFire)
{
relatedCharState.SpecialSightsFire(() =>
{
if (needActionDeal)
{
relatedAppearance.RemountWeaponOnRightHand();
}
attackProxy.RuntimeComponent.FinishPullBolt();
});
}
else
{
relatedCharState.SpecialFire(() =>
{
if (needActionDeal)
{
relatedAppearance.RemountWeaponOnRightHand();
}
attackProxy.RuntimeComponent.FinishPullBolt();
});
}
if (needActionDeal)
{
relatedAppearance.MountWeaponOnAlternativeLocator();
}
}
/// <summary>
/// 判断特殊换弹逻辑
/// </summary>
/// <param name="playerWeapon"></param>
/// <param name="cmd"></param>
/// <returns>是否可以射击</returns>
private bool CheckSpecialReload(WeaponAttackProxy attackProxy)
{
var specialReload = attackProxy.CharacterState.GetActionState();
// DebugUtil.MyLog("GetActionState:"+controller.RelatedCharState.GetActionState());
if (specialReload != ActionInConfig.Reload && specialReload != ActionInConfig.SpecialReload)
{
return(true);
}
var config = attackProxy.WeaponConfigAssy.S_CommonFireCfg;
if (config == null)
{
return(false);
}
if (config.SpecialReloadCount > 0 && attackProxy.BasicComponent.Bullet > 0)
{
if (attackProxy.BasicComponent.PullBolt)
{
//如果已经上膛，直接打断并开枪
attackProxy.CharacterState.ForceBreakSpecialReload(null);
return(true);
}
//如果没有上膛，执行上膛，结束后开枪
attackProxy.CharacterState.BreakSpecialReload();
attackProxy.BasicComponent.PullBolt = true;
attackProxy.RuntimeComponent.NeedAutoBurstShoot = false;
}
else
{
attackProxy.AudioController.PlayEmptyFireAudio();
}
return(false);
}
protected override void Update(WeaponAttackProxy attackProxy, WeaponSideCmd cmd)
{
var config = attackProxy.WeaponConfigAssy.S_FixedSpreadLogicCfg;
FireSpreadFormula.ApplyFixedFinalSpread(config.Value, config.SpreadScale, attackProxy.RuntimeComponent);
}
