public virtual void OnAfterFire(PlayerWeaponController controller, IWeaponCmd cmd)
{
if (controller.RelatedCameraSNew != null && controller.RelatedCameraSNew.ViewNowMode == (int)ECameraViewMode.GunSight)
{
if (controller.RelatedCharState != null)
{
controller.RelatedCharState.SightsFire();
}
else
{
Logger.Error("player has no stateInterface");
}
}
else
{
if (controller.RelatedCharState != null)
{
controller.RelatedCharState.Fire();
}
else
{
Logger.Error("player has no stateInterface");
}
}
}
private void CallOnIdle(IPlayerWeaponState playerWeapon, IWeaponCmd cmd)
{
foreach (var fireIdle in _idles)
{
fireIdle.OnIdle(playerWeapon, cmd);
}
}
private void CallOnFrame(IPlayerWeaponState playerWeapon, IWeaponCmd cmd)
{
foreach (var beforeFire in _frames)
{
beforeFire.OnFrame(playerWeapon, cmd);
}
}
private void CallAfterFireCmds(IPlayerWeaponState playerWeapon, IWeaponCmd cmd, int bulletCount)
{
foreach (var afterfire in _afterFireCmds)
{
afterfire.AfterFireCmd(playerWeapon, cmd, bulletCount);
}
}
private void CallBeforeFire(IPlayerWeaponState playerWeapon, IWeaponCmd cmd, int bullet)
{
foreach (var beforeFire in _beforeFires)
{
beforeFire.BeforeFireBullet(playerWeapon, cmd, bullet);
}
}
public void OnFrame(PlayerWeaponController controller, IWeaponCmd cmd)
{
if (!_initialized)
{
_initialized = true;
}
if (cmd.IsFire && cmd.FilteredInput.IsInput(EPlayerInput.IsLeftAttack))
{
DoReady(controller, cmd);
}
if (cmd.SwitchThrowMode)
{
DoSwitchMode(controller, cmd);
}
if (cmd.IsReload && cmd.FilteredInput.IsInput(EPlayerInput.IsReload))
{
DoPull(controller, cmd);
}
if (cmd.IsThrowing && cmd.FilteredInput.IsInput(EPlayerInput.IsThrowing))
{
DoThrowing(controller, cmd);
}
//判断打断
CheckBrokeThrow(controller, cmd);
}
public void AfterAttack(IPlayerWeaponState playerWeapon, IWeaponCmd cmd)
{
playerWeapon.MeleeAttacking = true;
playerWeapon.NextAttackingTimeLimit = playerWeapon.ClientTime + _maxCD;
if (null != _soundLogic)
{
//_soundLogic.PlaySound(playerWeapon.Key, XmlConfig.EWeaponSoundType.LeftFire1);
}
if (null != _effectLogic)
{
}
if (cmd.IsFire)
{
playerWeapon.StartMeleeAttack(cmd.RenderTime + _config.AttackInterval / 2,
new MeleeAttackInfo {
AttackType = MeleeAttckType.LeftMeleeAttack
},
_config);
}
else
{
playerWeapon.StartMeleeAttack(cmd.RenderTime + _config.SpecialAttackInterval / 2,
new MeleeAttackInfo {
AttackType = MeleeAttckType.RightMeleeAttack
},
_config);
}
playerWeapon.OnWeaponCost();
}
private void CallBeforeFires(PlayerWeaponController controller, IWeaponCmd cmd)
{
foreach (var beforeFire in _beforeFires)
{
beforeFire.BeforeFireBullet(controller, cmd);
}
}
private void CallOnIdle(PlayerWeaponController controller, IWeaponCmd cmd)
{
foreach (var fireIdle in _idles)
{
fireIdle.OnIdle(controller, cmd);
}
}
private void CallBulletFires(PlayerWeaponController controller, IWeaponCmd cmd)
{
foreach (var bulletfire in _bulletFires)
{
bulletfire.OnBulletFire(controller, cmd);
}
}
private void CallAfterFires(PlayerWeaponController controller, IWeaponCmd cmd)
{
foreach (var afterfire in _afterFires)
{
afterfire.OnAfterFire(controller, cmd);
}
}
public void BeforeFireBullet(PlayerWeaponController weaponController, IWeaponCmd cmd)
{
var weaponState = weaponController.HeldWeaponAgent.RunTimeComponent;
if (weaponState.LastFireTime == 0)
{
}
else
{
var config = weaponController.HeldWeaponAgent.PistolAccuracyLogicCfg;
if (config == null)
{
return;
}
var accuracy = weaponState.Accuracy;
accuracy -= config.AccuracyFactor * (0.3f - (cmd.RenderTime - weaponState.LastFireTime) / 1000.0f);
if (accuracy > config.MaxAccuracy)
{
accuracy = config.MaxAccuracy;
}
else if (accuracy < config.MinAccuracy)
{
accuracy = config.MinAccuracy;
}
weaponState.Accuracy = accuracy;
}
}
public void OnFrame(PlayerWeaponController controller, IWeaponCmd cmd)
{
bool isFire = false;
//判断是否有开火触发
foreach (var fireTrigger in _fireTrigggers)
{
isFire |= fireTrigger.IsTrigger(controller, cmd);
}
if (isFire)
{
//判断是否有开火限制
foreach (var fireCheck in _fireChecks)
{
isFire &= fireCheck.IsCanFire(controller, cmd);
}
}
if (isFire)
{
Fire(controller, cmd);
}
else
{
CallOnIdle(controller, cmd);
}
CallOnFrame(controller, cmd);
}
public void OnIdle(PlayerWeaponController controller, IWeaponCmd cmd)
{
var config = controller.HeldWeaponAgent.RifleFireCounterCfg;
if (config == null)
{
return;
}
var weaponState = controller.HeldWeaponAgent.RunTimeComponent;
if (weaponState.ContinuesShootDecreaseNeeded)
{
weaponState.ContinuesShootDecreaseNeeded = false;
if (weaponState.ContinuesShootCount > config.MaxCount)
{
weaponState.ContinuesShootCount = config.MaxCount;
}
weaponState.ContinuesShootDecreaseTimer = controller.RelatedTime + config.DecreaseInitInterval;
}
if (weaponState.ContinuesShootCount > 0 && weaponState.ContinuesShootDecreaseTimer <= controller.RelatedTime)
{
weaponState.ContinuesShootDecreaseTimer = controller.RelatedTime + config.DecreaseStepInterval;
weaponState.ContinuesShootCount--;
}
}
public void AfterAttack(PlayerWeaponController controller, IWeaponCmd cmd)
{
var weaponState = controller.HeldWeaponAgent.RunTimeComponent;
weaponState.MeleeAttacking = true;
weaponState.NextAttackingTimeLimit = controller.RelatedTime.ClientTime + _maxCD;
//TODO 声音和特效添加
if (cmd.IsFire)
{
StartMeleeAttack(controller, cmd.RenderTime + _config.AttackInterval,
new MeleeAttackInfo {
AttackType = MeleeAttckType.LeftMeleeAttack
},
_config);
}
else
{
StartMeleeAttack(controller, cmd.RenderTime + _config.SpecialAttackInterval,
new MeleeAttackInfo {
AttackType = MeleeAttckType.RightMeleeAttack
},
_config);
}
controller.ExpendAfterAttack();
}
private void CallOnFrame(PlayerWeaponController controller, IWeaponCmd cmd)
{
foreach (var beforeFire in _frames)
{
beforeFire.OnFrame(controller, cmd);
}
}
public void OnFrame(IPlayerWeaponState playerWeapon, IWeaponCmd cmd)
{
int frameInterval = cmd.FrameInterval;
if (playerWeapon.PunchDecayCdTime > 0)
{
playerWeapon.PunchDecayCdTime -= frameInterval;
}
else
{
var punchYaw = playerWeapon.NegPunchYaw;
var punchPitch = playerWeapon.NegPunchPitch;
var frameTime = frameInterval / 1000f;
var len = (float)Mathf.Sqrt(punchYaw * punchYaw + punchPitch * punchPitch);
if (len > 0)
{
punchYaw = punchYaw / len;
punchPitch = punchPitch / len;
len = UpdateLen(len, frameTime);
var lastYaw = playerWeapon.NegPunchYaw;
playerWeapon.NegPunchYaw = punchYaw * len;
playerWeapon.NegPunchPitch = punchPitch * len;
var factor = GetWeaponPunchYawFactor(playerWeapon);
playerWeapon.WeaponPunchYaw = playerWeapon.NegPunchYaw * factor;
playerWeapon.WeaponPunchPitch = playerWeapon.NegPunchPitch * factor;
}
}
}
public void OnFrame(PlayerWeaponController controller, IWeaponCmd cmd)
{
bool isFire = false;
//#if UNITY_EDITOR
// controller.SyncDebugInfo();
//#endif
//判断是否有开火触发
foreach (var fireTrigger in _fireTrigggers)
{
isFire |= fireTrigger.IsTrigger(controller, cmd);
}
if (isFire)
{
// DebugUtil.LogInUnity("controller:"+ controller.ToString(), DebugUtil.DebugColor.Blue);
//判断是否有开火限制
foreach (var fireCheck in _fireChecks)
{
isFire &= fireCheck.IsCanFire(controller, cmd);
}
}
if (isFire)
{
// DebugUtil.LogInUnity("Fire checker enabled ", DebugUtil.DebugColor.Blue);
Fire(controller, cmd);
}
else
{
CallOnIdle(controller, cmd);
}
CallOnFrame(controller, cmd);
}
public override void BeforeFireBullet(IPlayerWeaponState playerWeapon, IWeaponCmd cmd, int bullet)
{
float spread = UpdateSpread(playerWeapon, playerWeapon.LastAccuracy);
playerWeapon.LastSpreadX = spread * _config.SpreadScale.ScaleX;
playerWeapon.LastSpreadY = spread * _config.SpreadScale.ScaleY;
}
public void OnFrame(IPlayerWeaponState playerWeapon, IWeaponCmd cmd)
{
playerWeapon.IsPrevCmdFire = cmd.IsFire;
if (cmd.IsSwitchFireMode && cmd.FilteredInput.IsInput(XmlConfig.EPlayerInput.IsSwitchFireMode))
{
EFireMode mode = playerWeapon.FireMode;
EFireMode nextMode = _config.AvaiableModes[0];
for (int i = 0; i < _config.AvaiableModes.Length; i++)
{
if (_config.AvaiableModes[i] == mode)
{
nextMode = _config.AvaiableModes[(i + 1) % _config.AvaiableModes.Length];
}
}
if (nextMode == mode)
{
playerWeapon.ShowFireModeUnchangeTip();
}
else
{
playerWeapon.ShowFireModeChangeTip(nextMode);
}
playerWeapon.FireMode = nextMode;
playerWeapon.OnSwitchMode(_common);
}
}
public void AfterFireBullet(IPlayerWeaponState playerWeapon, IWeaponCmd cmd, int bullet)
{
if (playerWeapon.FireMode != WeaponConfigNs.EFireMode.Burst)
{
playerWeapon.BurstShootCount = 0;
Running = false;
return;
}
playerWeapon.BurstShootCount += 1;
if (playerWeapon.BurstShootCount < MaxBurstCount)
{
playerWeapon.NextAttackTimer = (playerWeapon.ClientTime + BurstInterval);
Running = true;
}
else
{
playerWeapon.NextAttackTimer = (playerWeapon.ClientTime + AttackInterval);
playerWeapon.BurstShootCount = 0;
Running = false;
}
if (IsTheLastBullet(playerWeapon))
{
playerWeapon.BurstShootCount = 0;
Running = false;
}
}
public override void OnIdle(IPlayerWeaponState playerWeapon, IWeaponCmd cmd)
{
if (playerWeapon.ContinuesShootCount == 0)
{
playerWeapon.LastAccuracy = _config.InitAccuracy;
}
}
public void BeforeFireBullet(PlayerWeaponController controller, IWeaponCmd cmd)
{
var weaponState = controller.HeldWeaponAgent.RunTimeComponent;
weaponState.ContinuesShootDecreaseNeeded = true;
weaponState.ContinuesShootCount++;
}
public override void OnIdle(PlayerWeaponController controller, IWeaponCmd cmd)
{
if (cmd.IsFire)
{
return;
}
var state = controller.RelatedCharState.GetActionState();
//开火中：重置拉栓
if (state == ActionInConfig.SpecialFireHold)
{
controller.RelatedCharState.SpecialFireEnd();
SetPullBolting(controller, true);
controller.AudioController.PlayPullBoltAudio(controller.HeldWeaponAgent.ConfigId);
return;
}
//拉栓行为结束：拉栓成功
if (state != ActionInConfig.SpecialFireEnd)
{
SetPullBolting(controller, false);
}
// if (IsFireHold(controller))
// {
// EndSpecialFire(controller);
// SetPullBolting(controller, true);
// controller.AudioController.PlayPullBoltAudio(weaponAgent.ConfigId);
// return;
// }
// if (!IsFireEnd(controller) && !IsFireHold(controller))
// {
// SetPullBolting(controller, false);
// }
}
public virtual void OnAfterFire(PlayerWeaponController controller, IWeaponCmd cmd)
{
int weaponId = controller.HeldWeaponAgent.ConfigId.Value;
var needActionDeal = CheckNeedActionDeal(weaponId, ActionDealEnum.Fire);
OnAfterFire(controller, needActionDeal);
}
public void BeforeFireBullet(PlayerWeaponController weaponController, IWeaponCmd cmd)
{
var config = weaponController.HeldWeaponAgent.BaseAccuracyLogicCfg;
if (config == null)
{
return;
}
Components.Weapon.WeaponRuntimeDataComponent weaponState = weaponController.HeldWeaponAgent.RunTimeComponent;
int accuracyDivisor = config.AccuracyDivisor;
if (accuracyDivisor != -1)
{
int shotsFired = weaponState.ContinuesShootCount;
float maxInaccuracy = config.MaxInaccuracy;
float accuracyOffset = config.AccuracyOffset;
float accuracy = shotsFired * shotsFired * shotsFired / accuracyDivisor + accuracyOffset;
if (accuracy > maxInaccuracy)
{
accuracy = maxInaccuracy;
}
weaponState.Accuracy = accuracy;
}
else
{
weaponState.Accuracy = 0;
}
}
public void OnFrame(PlayerWeaponController controller, IWeaponCmd cmd)
{
var heldAgent = controller.HeldWeaponAgent;
heldAgent.RunTimeComponent.IsPrevCmdFire = cmd.IsFire;
if (cmd.IsSwitchFireMode && cmd.FilteredInput.IsInput(XmlConfig.EPlayerInput.IsSwitchFireMode))
{
var config = heldAgent.DefaultFireModeLogicCfg;
if (config == null || config == null)
{
return;
}
EFireMode mode = (EFireMode)heldAgent.BaseComponent.RealFireModel;
EFireMode nextMode = config.AvaliableModes[0];
for (int i = 0; i < config.AvaliableModes.Length; i++)
{
if (config.AvaliableModes[i] == mode)
{
nextMode = config.AvaliableModes[(i + 1) % config.AvaliableModes.Length];
}
}
if (nextMode == mode)
{
controller.ShowTip(ETipType.FireModeLocked);
}
else
{
ShowFireModeChangeTip(controller, nextMode);
}
heldAgent.BaseComponent.FireModel = (int)nextMode;
// controller.AudioController.SwitchFireMode(nextMode);
// controller.PlayWeaponSound(XmlConfig.EWeaponSoundType.SwitchFireMode);
}
}
public void OnAfterFire(PlayerWeaponController controller, IWeaponCmd cmd)
{
var heldAgent = controller.HeldWeaponAgent;
if (heldAgent.BaseComponent.FireMode != (int)EFireMode.Burst)
{
heldAgent.RunTimeComponent.BurstShootCount = 0;
EnableAutoFire(controller, false);
return;
}
var config = heldAgent.DefaultFireModeLogicCfg;
if (config == null)
{
return;
}
heldAgent.RunTimeComponent.BurstShootCount += 1;
if (heldAgent.RunTimeComponent.BurstShootCount < config.BurstCount)
{
heldAgent.RunTimeComponent.NextAttackTimer = (cmd.RenderTime + config.BurstAttackInnerInterval);
EnableAutoFire(controller, true);
}
else
{
heldAgent.RunTimeComponent.NextAttackTimer = (cmd.RenderTime + config.BurstAttackInterval);
heldAgent.RunTimeComponent.BurstShootCount = 0;
EnableAutoFire(controller, false);
}
if (IsTheLastBullet(controller))
{
controller.HeldWeaponAgent.RunTimeComponent.BurstShootCount = 0;
EnableAutoFire(controller, false);
}
}
public void BeforeFireBullet(PlayerWeaponController controller, IWeaponCmd cmd)
{
var config = controller.HeldWeaponAgent.FixedSpreadLogicCfg;
var weaponState = controller.HeldWeaponAgent.RunTimeComponent;
float spread = UpdateSpread(controller, weaponState.Accuracy);
weaponState.LastSpreadX = spread * config.SpreadScale.ScaleX;
weaponState.LastSpreadY = spread * config.SpreadScale.ScaleY;
}
public void OnFrame(PlayerWeaponController controller, IWeaponCmd cmd)
{
var weaponId = controller.HeldWeaponAgent.ConfigId;
// _attackTimeController.TimeUpdate(cmd.FrameInterval * 0.001f, weaponId);
var weaponState = controller.HeldWeaponAgent.RunTimeComponent;
// if(!_attackTimeController.CanAttack) return;
// if (playerEntity.time.ClientTime < weaponState.NextAttackTimePeriodStamp) return;
var nowTime = controller.RelatedTime.ClientTime;
var delta = weaponState.NextAttackPeriodStamp - nowTime;
delta = weaponState.ContinueAttackEndStamp - nowTime;
if (cmd.IsFire)
{
// 轻击1
if (nowTime > weaponState.NextAttackPeriodStamp)
{
controller.RelatedStateInterface.LightMeleeAttackOne(OnAttackAniFinish);
// _attackTimeController.SetMeleeInterprutTime(_config.AttackInterval);
weaponState.NextAttackPeriodStamp = nowTime + _config.AttackTotalInterval; //目前表里配的间隔时间是结束后到开始时间
weaponState.ContinueAttackStartStamp = nowTime + _config.AttackOneCD;
weaponState.ContinueAttackEndStamp = nowTime + _config.ContinousInterval;
// DebugUtil.LogInUnity("First MeleeAttack", DebugUtil.DebugColor.Green);
}
// if (playerEntity.time.ClientTime > weaponState.ContinuousAttackTime)
//{
// playerEntity.stateInterface.State.LightMeleeAttackOne(() => { _attackTimeController.FinishAttack();});
// _attackTimeController.SetMeleeInterprutTime(_config.AttackInterval);
// weaponState.NextAttackTimePeriodStamp = playerEntity.time.ClientTime + _config.AttackTotalInterval; //目前表里配的间隔时间是结束后到开始时间
// Logger.InfoFormat("MeleeAttackOne----------------");
// 轻击2
else if (CompareUtility.IsBetween(nowTime, weaponState.ContinueAttackStartStamp, weaponState.ContinueAttackEndStamp))
{
weaponState.ContinueAttackStartStamp = 0;
weaponState.ContinueAttackEndStamp = 0;
weaponState.NextAttackPeriodStamp = Math.Max(nowTime + _config.AttackOneCD, weaponState.ContinueAttackEndStamp);
controller.RelatedStateInterface.LightMeleeAttackTwo(OnAttackAniFinish);
// _attackTimeController.SetMeleeInterprutTime(_config.AttackInterval);
//weaponState.ContinuousAttackTime = playerEntity.time.ClientTime;
// DebugUtil.LogInUnity("Second MeleeAttack", DebugUtil.DebugColor.Green);
}
AfterAttack(controller, cmd);
}
else if (cmd.IsSpecialFire && nowTime >= weaponState.NextAttackPeriodStamp)
{
controller.RelatedStateInterface.MeleeSpecialAttack(OnAttackAniFinish);
// _attackTimeController.SetMeleeInterprutTime(_config.SpecialAttackInterval);
Logger.InfoFormat("MeleeAttackSpecial----------------");
weaponState.NextAttackPeriodStamp = nowTime + _config.SpecialDamageInterval;
AfterAttack(controller, cmd);
}
}
