public void BeforeExecuteUserCmd(IUserCmdOwner owner, IUserCmd cmd)
{
PlayerEntity playerEntity = owner.OwnerEntity as PlayerEntity;
if (!playerEntity.hasCharacterContoller || !playerEntity.hasPlayerRotateLimit || !playerEntity.hasPosition || !playerEntity.hasOrientation)
{
return;
}
var controller = playerEntity.characterContoller.Value;
var limitComponent = playerEntity.playerRotateLimit;
if (controller.enabled && controller.GetCurrentControllerType() == CharacterControllerType.ProneKinematicCharacterController)
{
var bound = controller.GetRotateBound(playerEntity.orientation.ModelView, playerEntity.position.Value, cmd.FrameInterval);
var yaw = YawPitchUtility.Normalize(playerEntity.orientation.ModelYaw);
limitComponent.SetLimit(yaw + bound.Key, yaw + bound.Value);
//Logger.InfoFormat("seq:{0}, lowerBound:{1}, upperBoound:{2}, cur Yaw:{3}", cmd.Seq ,bound.Key, bound.Value, yaw);
}
else
{
limitComponent.SetNoLimit();
}
}
private void RewindNetworkAnimator(IUserCmd cmd, PlayerEntity playerEntity)
{
// 预测回滚
if (playerEntity.fpAnimStatus.NeedRewind)
{
_logger.WarnFormat("rewind fpAnimStatus:{0}!!!", playerEntity.entityKey.Value);
_poseReplayer.ReplayPose(playerEntity.fpAnimStatus.AnimatorLayers,
playerEntity.fpAnimStatus.AnimatorParameters,
playerEntity.firstPersonAnimator.UnityAnimator);
// if rewind for history not saved, should not update
if (playerEntity.fpAnimStatus.BaseClientTime != 0)
{
playerEntity.firstPersonAnimator.UnityAnimator.Update(
(cmd.ClientTime - playerEntity.networkAnimator.BaseClientTime - cmd.FrameInterval) * 0.001f);
}
}
if (playerEntity.networkAnimator.NeedRewind)
{
_logger.WarnFormat("rewind networkAnimator:{0}!!!", playerEntity.entityKey.Value);
_poseReplayer.ReplayPose(playerEntity.networkAnimator.AnimatorLayers,
playerEntity.networkAnimator.AnimatorParameters,
playerEntity.thirdPersonAnimator.UnityAnimator);
// if rewind for history not saved, should not update
if (playerEntity.networkAnimator.BaseClientTime != 0)
{
playerEntity.thirdPersonAnimator.UnityAnimator.Update(
(cmd.ClientTime - playerEntity.networkAnimator.BaseClientTime - cmd.FrameInterval) * 0.001f);
//_logger.InfoFormat("rewind for history not saved, should not update, seq:{0}, SnapshotId:{1}", cmd.Seq, cmd.SnapshotId);
}
}
}
public void ExecuteUserCmd(IUserCmdOwner owner, IUserCmd cmd)
{
var player = owner.OwnerEntity as PlayerEntity;
var controller = player.WeaponController();
if (IsNotAliveThenIgnoreCmd(player))
{
return;
}
if (cmd.PickUpEquip > 0)
{
if (cmd.IsManualPickUp)
{
player.ModeController().DoPickup(player, cmd.PickUpEquip);
}
else
{
player.ModeController().AutoPickupWeapon(player, cmd.PickUpEquip);
}
}
else if (cmd.FilteredInput.IsInput(XmlConfig.EPlayerInput.IsDropWeapon))
{
player.ModeController().Drop(player, controller.HeldSlotType);
}
//投掷时会判断是否已经准备，手雷的对象为Playback，不存在预测回滚的问题
if (controller.AutoThrowing.HasValue && controller.AutoThrowing.Value)
{
if (null != _userCmdGenerator)
{
_userCmdGenerator.SetUserCmd((userCmd) => {
userCmd.IsThrowing = true;
});
controller.AutoThrowing = false;
}
}
}
protected override void ExecuteUserCmd(PlayerEntity playerEntity, IUserCmd cmd)
{
var weaponController = playerEntity.WeaponController();
weaponController.InternalUpdate(playerEntity);
if (!playerEntity.playerClientUpdate.OpenUIFrame)
{
return;
}
playerEntity.playerClientUpdate.OpenUIFrame = false;
if (weaponController.RelatedThrowAction.IsReady && !weaponController.RelatedThrowAction.IsThrow)
{
var throwing =
_contexts.throwing.GetEntityWithEntityKey(weaponController
.RelatedThrowAction.ThrowingEntityKey);
if (null != throwing)
{
throwing.isFlagDestroy = true;
}
weaponController.RelatedCharState.ForceFinishGrenadeThrow();
weaponController.RelatedThrowAction.ClearState();
}
}
protected override void ExecWhenNormal(PlayerEntity player, IUserCmd cmd)
{
if (!player.hasCameraObj)
{
return;
}
if (!player.hasCameraFinalOutputNew)
{
return;
}
if (!player.hasCameraStateOutputNew)
{
return;
}
UpdateCollisionLayerMask(player);
var punchRotation = new Vector3(2 * player.orientation.PunchPitch,
player.orientation.PunchYaw, player.orientation.FireRoll);
UpdateCollisions(player.cameraStateOutputNew, player.cameraFinalOutputNew, punchRotation,
player, !player.appearanceInterface.Appearance.IsFirstPerson, cmd.ClientTime);
SingletonManager.Get <DurationHelp>().Position = player.cameraStateOutputNew.ArchorPosition;
}
public void ExecuteUserCmd(IUserCmdOwner owner, IUserCmd cmd)
{
var player = owner.OwnerEntity as PlayerEntity;
if (IsNotAliveThenIgnoreCmd(player))
{
return;
}
if (cmd.PickUpEquip > 0)
{
if (cmd.IsManualPickUp)
{
player.modeLogic.ModeLogic.DoPickup(player.entityKey.Value.EntityId, cmd.PickUpEquip);
}
else
{
player.modeLogic.ModeLogic.AutoPickupWeapon(player.entityKey.Value.EntityId, cmd.PickUpEquip);
}
}
//TODO 暂时没有考虑回滚，后续需对回滚的情况做处理
if (player.hasWeaponAutoState && player.weaponAutoState.AutoThrowing)
{
if (null != _userCmdGenerator)
{
_userCmdGenerator.SetUserCmd((userCmd) => {
userCmd.IsThrowing = true;
});
player.weaponAutoState.AutoThrowing = false;
}
}
if (cmd.FilteredInput.IsInput(XmlConfig.EPlayerInput.IsDropWeapon))
{
var slot = (EWeaponSlotType)player.weaponState.CurrentWeaponSlot;
player.modeLogic.ModeLogic.Dorp(player.entityKey.Value.EntityId, slot);
}
}
protected override void UpdateState(Contexts contexts, PlayerEntity player, IUserCmd cmd)
{
player.playerSkyMove.ParachuteTime += cmd.FrameInterval * 0.001f;
var moveConfig = SingletonManager.Get <CharacterStateConfigManager>().SkyMoveConfig;
if (cmd.IsUseAction && player.playerSkyMove.ParachuteTime > moveConfig.ParachuteTime)
{
if (SharedConfig.IsOffline)
{
OpenParachute(contexts, player);
}
else if (player.gamePlay.GameState == GameState.Gliding)
{
OpenParachute(contexts, player);
}
}
if (player.playerSkyMove.IsReadyForAttachParachute() ||
!IsAboveGround(player, player.position.Value, moveConfig.MinParachuteHeight))
{
OpenParachute(contexts, player);
}
}
public static void ReleaseKey(IUserCmd cmd, int key)
{
SetKey(cmd, key, false);
}
public void SetUserCmd(IUserCmd cmd)
{
this._cmd = cmd;
}
public static void SyncToFirePositionComponent(FirePosition component, PlayerEntity playerEntity, IUserCmd cmd)
{
SyncSightFirePos(component, playerEntity);
SyncMuzzleP3Pos(component, playerEntity);
// DebugUtil.MyLog( "[seq:{1}]MuzzleP3Position before:{0}",component.MuzzleP3Position,cmd.Seq);
}
public override void Drop(PlayerEntity player, EWeaponSlotType slot, IUserCmd cmd)
{
}
public virtual void Update(IUserCmd cmd)
{
}
protected override void ExecWhenObserving(PlayerEntity player, IUserCmd cmd)
{
}
public void BeforeExecuteUserCmd(IUserCmdOwner owner, IUserCmd cmd)
{
UpdateCamera(owner, cmd);
}
public void ExecuteUserCmd(IUserCmdOwner owner, IUserCmd cmd)
{
PlayerEntity player = (PlayerEntity)owner.OwnerEntity;
if (cmd.IsReload)// && cmd.FilteredInput.IsInput(EPlayerInput.IsReload))
{
if (!cmd.FilteredInput.IsInput(EPlayerInput.IsReload) && !player.playerMove.IsAutoRun)
{
return;
}
if (!player.hasBag)
{
return;
}
var bagImp = player.bag.Bag as WeaponBagLogic;
if (!bagImp.HasWeapon())
{
return;
}
var weapon = bagImp.GetCurrentWeaponInfo();
var config = SingletonManager.Get <WeaponConfigManager>().GetConfigById(weapon.Id);
if (NoReloadAction(config))
{
return;
}
if (MagazineIsFull(player.weaponLogic.State, weapon.Bullet))
{
return;
}
if (HasNoReservedBullet(bagImp, player))
{
return;
}
if (!_reloading)
{
player.weaponLogic.WeaponSound.PlaySound(EWeaponSoundType.ClipDrop);
_reloading = true;
}
var weaponState = player.weaponLogic.State;
var reloadSpeed = weaponState.ReloadSpeed;
reloadSpeed = Mathf.Max(0.1f, reloadSpeed);
player.playerMove.InterruptAutoRun();
player.animatorClip.ClipManager.SetReloadSpeedBuff(reloadSpeed);
if (weaponState.SpecialReloadCount > 0)
{
var target = weaponState.BulletCountLimit - weaponState.LoadedBulletCount;
target = Mathf.Min(target, weaponState.ReservedBulletCount);
var count = Mathf.CeilToInt((float)target / weaponState.SpecialReloadCount);
count = Mathf.Max(1, count);
player.stateInterface.State.SpecialReload(
() =>
{
SpecialReload(weaponState);
},
count,
() =>
{ //换弹结束回调
player.animatorClip.ClipManager.ResetReloadSpeedBuff();
});
}
else
{
if (weaponState.LoadedBulletCount > 0 && !weaponState.IsAlwaysEmptyReload)
{
var needActionDeal = CheckNeedActionDeal(bagImp, ActionDealEnum.Reload);
if (needActionDeal)
{
player.appearanceInterface.Appearance.MountWeaponOnAlternativeLocator();
}
player.stateInterface.State.Reload(() =>
{
if (needActionDeal)
{
player.appearanceInterface.Appearance.RemountWeaponOnRightHand();
}
Reload(weaponState);
player.animatorClip.ClipManager.ResetReloadSpeedBuff();
_reloading = false;
});
}
else
{
var needActionDeal = CheckNeedActionDeal(bagImp, ActionDealEnum.ReloadEmpty);
if (needActionDeal)
{
player.appearanceInterface.Appearance.MountWeaponOnAlternativeLocator();
}
player.stateInterface.State.ReloadEmpty(() =>
{
if (needActionDeal)
{
player.appearanceInterface.Appearance.RemountWeaponOnRightHand();
}
Reload(weaponState);
player.animatorClip.ClipManager.ResetReloadSpeedBuff();
_reloading = false;
});
}
}
}
}
public void ExecuteUserCmd(IUserCmdOwner owner, IUserCmd cmd)
{
if ((!cmd.IsAutoReload && !cmd.FilteredInput.IsInput(EPlayerInput.IsReload)) ||
cmd.FilteredInput.IsInput(EPlayerInput.IsLeftAttack))
{
return; //按住鼠标左键时不可换弹
}
PlayerEntity player = (PlayerEntity)owner.OwnerEntity;
if (player.playerMove.IsAutoRun)
{
return;
}
// if (!player.ModeController().CanModeAutoReload) return;
var weaponController = player.WeaponController();
var heldWeaponAgent = weaponController.HeldWeaponAgent;
heldWeaponAgent.RunTimeComponent.NeedAutoReload = false;
if (!heldWeaponAgent.IsValid() || //heldWeaponAgent.BaseComponent.Bullet > 0
heldWeaponAgent.WeaponConfigAssy.CanotReloadBullet ||
heldWeaponAgent.CommonFireCfg == null)
{
return;
}
var reservedBullet = weaponController.GetReservedBullet();
if (reservedBullet < 1)
{
if (SharedConfig.CurrentGameMode == EGameMode.Normal)
{
player.tip.TipType = ETipType.BulletRunout;
}
else
{
player.tip.TipType = ETipType.NoBulletInPackage;
}
return;
}
//检查总弹量
int maxSizeBulletCount = heldWeaponAgent.WeaponConfigAssy.PropertyCfg.Bullet;
if (heldWeaponAgent.BaseComponent.Magazine > 0)
{
maxSizeBulletCount += SingletonManager
.Get <WeaponPartsConfigManager>()
.GetConfigById(heldWeaponAgent.BaseComponent.Magazine).Bullet;
}
if (heldWeaponAgent.BaseComponent.Bullet >= maxSizeBulletCount)
{
return;
}
if (!_reloading)
{
//player.PlayWeaponSound(EWeaponSoundType.ClipDrop);
_reloading = true;
}
var reloadSpeed = Mathf.Max(0.1f, heldWeaponAgent.ReloadSpeed);
player.autoMoveInterface.PlayerAutoMove.StopAutoMove();
player.animatorClip.ClipManager.SetReloadSpeedBuff(reloadSpeed);
//走特殊换弹逻辑
var specialReloadCount = heldWeaponAgent.CommonFireCfg.SpecialReloadCount;
if (specialReloadCount > 0)
{
var reloadedBulletCount = maxSizeBulletCount - heldWeaponAgent.BaseComponent.Bullet;
reloadedBulletCount = Mathf.Min(reloadedBulletCount, reservedBullet);
reloadedBulletCount = Mathf.CeilToInt((float)reloadedBulletCount / specialReloadCount);
reloadedBulletCount = Mathf.Max(1, reloadedBulletCount);
// player.AudioController().SetReloadBulletAudioCount(reloadedBulletCount);
player.stateInterface.State.SpecialReload(
() =>
{
SpecialReload(player, weaponController,
maxSizeBulletCount);
},
reloadedBulletCount,
() =>
{
//换弹结束回调
player.animatorClip.ClipManager.ResetReloadSpeedBuff();
});
}
else
{
if (heldWeaponAgent.BaseComponent.Bullet > 0 && !heldWeaponAgent.IsWeaponEmptyReload)
{
var needActionDeal = CheckNeedActionDeal(weaponController, ActionDealEnum.Reload);
if (needActionDeal)
{
player.appearanceInterface.Appearance.MountWeaponOnAlternativeLocator();
}
if (player.AudioController() != null)
{
player.AudioController()
.PlayReloadAudio(heldWeaponAgent.ConfigId, false);
}
player.stateInterface.State.Reload(() =>
{
if (needActionDeal)
{
player.appearanceInterface.Appearance.RemountWeaponOnRightHand();
}
Reload(player, weaponController, maxSizeBulletCount);
player.animatorClip.ClipManager.ResetReloadSpeedBuff();
_reloading = false;
});
}
else
{
var needActionDeal = CheckNeedActionDeal(weaponController, ActionDealEnum.ReloadEmpty);
if (needActionDeal)
{
player.appearanceInterface.Appearance.MountWeaponOnAlternativeLocator();
}
if (player.AudioController() != null)
{
player.AudioController()
.PlayReloadAudio(heldWeaponAgent.ConfigId, true);
}
player.stateInterface.State.ReloadEmpty(() =>
{
if (needActionDeal)
{
player.appearanceInterface.Appearance.RemountWeaponOnRightHand();
}
Reload(player, weaponController, maxSizeBulletCount);
player.animatorClip.ClipManager.ResetReloadSpeedBuff();
_reloading = false;
});
}
}
}
protected override void ExecuteUserCmd(PlayerEntity playerEntity, IUserCmd cmd)
{
SyncCameraFireInfo(playerEntity);
// DebugUtil.AppendShootText(cmd.Seq,"seq:{0} cmd:{1} player.position:{1}",cmd.Seq,cmd.MoveHorizontal,playerEntity.position.Value);
}
public void ExecuteUserCmd(IUserCmdOwner owner, IUserCmd cmd)
{
if (cmd.IsUseAction && cmd.UseType == (int)EUseActionType.Door)
{
var door = _context.GetEntityWithEntityKey(new Core.EntityComponent.EntityKey(cmd.UseEntityId, (short)EEntityType.MapObject));
if (door == null)
{
_logger.ErrorFormat("Door Entity {0} does not exist!", cmd.UseEntityId);
return;
}
if (!door.hasDoorRotate && door.doorData.IsOpenable())
{
var player = (PlayerEntity)owner.OwnerEntity;
player.playerMove.InterruptAutoRun();
var go = door.rawGameObject.Value;
var playerPosition = player.RootGo().transform.position;
var doorPosition = go.transform.position;
var direction = (playerPosition - doorPosition);
var dot = Vector3.Dot(direction, go.transform.forward);
var rot = go.transform.localEulerAngles.y;
rot = YawPitchUtility.Normalize(rot);
float from = rot, to = 0;
var state = door.doorData.State;
var endState = state;
if (dot > 0)
{
switch (state)
{
case (int)DoorState.Closed:
to = from + OpenMaxAngle;
endState = (int)DoorState.OpenMax;
break;
case (int)DoorState.OpenMin:
to = from - OpenMinAngle;
endState = (int)DoorState.Closed;
break;
case (int)DoorState.OpenMax:
to = from - OpenMaxAngle;
endState = (int)DoorState.Closed;
break;
}
}
else if (dot < 0)
{
switch (state)
{
case (int)DoorState.Closed:
to = from + OpenMinAngle;
endState = (int)DoorState.OpenMin;
break;
case (int)DoorState.OpenMin:
to = from - OpenMinAngle;
endState = (int)DoorState.Closed;
break;
case (int)DoorState.OpenMax:
to = from - OpenMaxAngle;
endState = (int)DoorState.Closed;
break;
}
}
if (endState != state)
{
player.stateInterface.State.OpenDoor();
if (SharedConfig.IsServer || SharedConfig.IsOffline)
{
door.doorData.State = (int)DoorState.Rotating;
door.AddDoorRotate(from, from, to, endState);
_logger.DebugFormat("Trigger Door From {0} {1} To {2} {3}",
state, from, endState, to);
switch ((DoorState)endState)
{
case DoorState.Closed:
player.soundManager.Value.PlayOnce(XmlConfig.EPlayerSoundType.CloseDoor);
break;
case DoorState.OpenMax:
case DoorState.OpenMin:
player.soundManager.Value.PlayOnce(XmlConfig.EPlayerSoundType.OpenDoor);
break;
}
}
}
}
}
}
public IFilteredInput ApplyUserCmd(IUserCmd userCmd, int debugMoveSignal)
{
return(inputManager.ApplyUserCmd(userCmd, debugMoveSignal));
}
public void ExecuteUserCmd(IUserCmdOwner owner, IUserCmd cmd)
{
Update(owner.OwnerEntityKey, cmd.FrameInterval);
}
protected override void DoDropGrenade(PlayerEntity playerEntity, EWeaponSlotType slot, IUserCmd cmd)
{
if (slot == EWeaponSlotType.ThrowingWeapon)
{
cmd.IsThrowing = true;
return;
}
}
//temporary: observed player calcu twice and upload data(final position and rotation) // observing player copy the data //should be: observed player upload states, observing player calcu with states protected abstract void ExecWhenBeingObserved(PlayerEntity player, IUserCmd cmd);
public void Drop(PlayerEntity player, EWeaponSlotType slot, IUserCmd cmd)
{
PickupHandler.Drop(player, slot, cmd);
}
protected abstract void ExecWhenNormal(PlayerEntity player, IUserCmd cmd);
/*public override void SendAutoPickupWeapon(int entityId)
* {
* var target = _contexts.sceneObject.GetEntityWithEntityKey(new EntityKey(entityId, (short)EEntityType.SceneObject));
* if (target != null && Player.WeaponController().FilterAutoPickup(target.simpleItem.Id))
* {
* var model = target.hasUnityObject ? target.unityObject.UnityObject : target.multiUnityObject.FirstAsset;
* if (CommonObjectCastUtil.HasObstacleBetweenPlayerAndItem(Player, target.position.Value, model))
* {
* return;
* }
*
* SimpleProto pickUp = FreePool.Allocate();
* pickUp.Key = FreeMessageConstant.PickUpItem;
* pickUp.Ins.Add(entityId);
* pickUp.Ins.Add(target.simpleItem.Category);
* pickUp.Ins.Add(target.simpleItem.Id);
* pickUp.Ins.Add(1);
* Player.network.NetworkChannel.SendReliable((int)EClient2ServerMessage.FreeEvent, pickUp);
* }
* }*/
protected override void DoDropGrenade(PlayerEntity playerEntity, EWeaponSlotType slot, IUserCmd cmd)
{
_userCmdGenerator.SetUserCmd((userCmd) => userCmd.IsLeftAttack = true);
playerEntity.WeaponController().AutoThrowing = true;
}
protected virtual void FinalExec(PlayerEntity player, IUserCmd cmd)
{
}
public static void PressKey(IUserCmd cmd, int key)
{
SetKey(cmd, key, true);
}
protected virtual void BeforeExec(PlayerEntity player, IUserCmd cmd)
{
}
private static void SetKey(IUserCmd cmd, int key, bool value)
{
if (key > NumberDelta)
{
if (value)
{
cmd.CurWeapon = key - NumberDelta;
}
else
{
cmd.CurWeapon = 0;
}
}
switch (key)
{
case SKILL:
cmd.IsF = value;
break;
case DEMOLITION:
cmd.IsPeekRight = value;
break;
case Q:
cmd.IsPeekLeft = value;
break;
case JUMP:
cmd.IsJump = value;
break;
case C:
cmd.IsCrouch = value;
break;
case RELOAD:
cmd.IsReload = value;
break;
case P:
cmd.IsPDown = value;
break;
case Y:
cmd.IsYDown = value;
break;
case THROWWEAPON:
cmd.IsDropWeapon = value;
break;
case TAB:
cmd.IsTabDown = value;
break;
case FORWARD:
cmd.MoveVertical = value ? 1 : 0;
break;
case BACKWARD:
cmd.MoveVertical = value ? -1 : 0;
break;
case LEFT:
cmd.MoveHorizontal = value ? -1 : 0;
break;
case RIGHT:
cmd.MoveHorizontal = value ? 1 : 0;
break;
case ATTACK:
cmd.IsLeftAttack = value;
break;
case ATTACK2:
cmd.IsRightAttack = value;
break;
case X:
cmd.IsDrawWeapon = value;
break;
case Z:
cmd.IsProne = value;
break;
case EQUAL:
cmd.IsSwitchAutoRun = value;
break;
case SHIFT:
cmd.IsRun = value;
break;
case CTRL:
cmd.IsSlightWalk = value;
break;
case SHOWGUN:
cmd.ChangeCamera = value;
break;
case B:
cmd.IsSwitchFireMode = value;
break;
case PageUp:
cmd.IsScopeIn = value;
break;
case PageDown:
cmd.IsScopeOut = value;
break;
default:
break;
}
}
protected abstract void ExecWhenObserving(PlayerEntity player, IUserCmd cmd);
