public override void UpdateHitBox(IGameEntity gameEntity, int renderTime, int cmdSeq)
{
var position = gameEntity.Position.Value;
var rotation = gameEntity.GetComponent <OrientationComponent>().ModelView;
var playerEntity = GetPlayerEntity(gameEntity);
var hitBoxComponent = GetHitBoxComponent(playerEntity);
if (hitBoxComponent != null)
{
playerEntity.thirdPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
PlayerEntityUtility.UpdateTransform(playerEntity, gameEntity.GetComponent <NetworkAnimatorComponent>(),
gameEntity.GetComponent <PredictedAppearanceComponent>(),
gameEntity.GetComponent <OrientationComponent>());
// DebugUtil.AppendShootText(renderTime, "server animator {0}",
// gameEntity.GetComponent<NetworkAnimatorComponent>().ToStringExt());
playerEntity.RootGo().transform.SetPositionAndRotation(position, rotation);
playerEntity.hitBox.RenderTime = renderTime;
// if (_logger.IsDebugEnabled)
// {
// StringBuilder s = new StringBuilder();
// hitBoxComponent.HitBoxGameObject.transform.Recursively(t => s.Append("[n " + t.name + ", p " + t.position.ToStringExt() + ", r " + t.rotation.ToStringExt() + "]"));
// // _logger.DebugFormat("hitbox pos {0}, rot {1}, transforms {2}, ", position, rotation, s);
// DebugUtil.AppendShootText(cmdSeq,"hitbox pos {0}, rot {1}, transforms {2}, ", position, rotation, s);
// }
base.UpdateHitBox(gameEntity, renderTime, cmdSeq);
}
}
public static ThrowingEntity CreateThrowingEntity(
ThrowingContext throwingContext,
IEntityIdGenerator entityIdGenerator,
PlayerEntity playerEntity,
int serverTime, Vector3 dir, float initVel,
NewWeaponConfigItem newWeaponConfig,
ThrowingConfig throwingConfig)
{
int throwingEntityId = entityIdGenerator.GetNextEntityId();
var emitPost = PlayerEntityUtility.GetThrowingEmitPosition(playerEntity);
Vector3 velocity = dir * initVel;
var throwingEntity = throwingContext.CreateEntity();
throwingEntity.AddEntityKey(new EntityKey(throwingEntityId, (int)EEntityType.Throwing));
throwingEntity.AddThrowingData(
velocity,
false,
false,
0,
serverTime,
false,
initVel,
throwingConfig,
newWeaponConfig.SubType
);
throwingEntity.AddPosition(emitPost);
throwingEntity.AddOwnerId(playerEntity.entityKey.Value);
throwingEntity.isFlagSyncNonSelf = true;
throwingEntity.AddLifeTime(DateTime.Now, throwingConfig.CountdownTime + 2000);
return(throwingEntity);
}
public void UpdateHitBox(IGameEntity gameEntity)
{
var position = gameEntity.Position.Value;
var rotation = gameEntity.GetComponent <OrientationComponent>().RotationYaw;
var hitBoxComponent = GetHitBoxComponent(gameEntity.EntityKey);
if (hitBoxComponent != null)
{
var playerEntity = GetPlayerEntity(gameEntity);
playerEntity.thirdPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
PlayerEntityUtility.UpdateTransform(playerEntity,
gameEntity.GetComponent <NetworkAnimatorComponent>(),
gameEntity.GetComponent <PredictedAppearanceComponent>(),
gameEntity.GetComponent <OrientationComponent>());
//_logger.DebugFormat("server animator {0}", gameEntity.GetComponent<NetworkAnimatorComponent>().ToStringExt());
PlayerEntityUtility.UpdateTransform(playerEntity,
playerEntity.networkAnimator,
playerEntity.predictedAppearance,
playerEntity.orientation);
playerEntity.thirdPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.CullUpdateTransforms;
if (_logger.IsDebugEnabled)
{
StringBuilder s = new StringBuilder();
hitBoxComponent.HitBoxGameObject.transform.Recursively(t => s.Append("[n " + t.name + ", p " + t.position.ToStringExt() + ", r " + t.rotation.ToStringExt() + "]"));
_logger.DebugFormat("hitbox pos {0}, rot {1}, transforms {2}, ", position, rotation, s);
}
}
}
private void StartFlying(PlayerEntity playerEntity, ThrowingEntity throwingEntity)
{
IPlayerWeaponState playerWeapon = playerEntity.weaponLogic.State;
var dir = BulletDirUtility.GetThrowingDir(playerWeapon);
Vector3 vel = dir * throwingEntity.throwingData.InitVelocity;
Vector3 pos = PlayerEntityUtility.GetThrowingEmitPosition(playerEntity);
throwingEntity.position.Value = pos;
throwingEntity.throwingData.Velocity = vel;
throwingEntity.throwingData.IsFly = true;
//扔掉手雷
playerWeapon.LastGrenadeId = playerEntity.grenade.Id;
if (SharedConfig.IsServer)
{
IEventArgs args = (IEventArgs)_contexts.session.commonSession.FreeArgs;
if (!args.Triggers.IsEmpty((int)EGameEvent.WeaponState))
{
SimpleParaList dama = new SimpleParaList();
dama.AddFields(new ObjectFields(playerWeapon));
dama.AddPara(new IntPara("CarryClip", playerWeapon.ReservedBulletCount));
dama.AddPara(new IntPara("Clip", playerWeapon.LoadedBulletCount));
dama.AddPara(new IntPara("ClipType", (int)playerWeapon.Caliber));
dama.AddPara(new IntPara("id", (int)playerWeapon.CurrentWeapon));
SimpleParable sp = new SimpleParable(dama);
args.Trigger((int)EGameEvent.WeaponState, new TempUnit[] { new TempUnit("state", sp), new TempUnit("current", (FreeData)((PlayerEntity)playerWeapon.Owner).freeData.FreeData) });
}
}
playerWeapon.LastGrenadeId = 0;
playerWeapon.IsThrowingStartFly = false;
//清理状态
CastGrenade(playerEntity);
}
private static void ClimbUpTest(Vector3 collisionPoint, PlayerEntity player, out GenericActionKind kind,
out float yTranslateOffset)
{
_kind = kind = GenericActionKind.Null;
yTranslateOffset = 0.0f;
var playerTransform = player.RootGo().transform;
var distance = collisionPoint.y - playerTransform.position.y;
if (distance < MinClimbHeight || distance > MaxClimbHeight)
{
return;
}
//最终位置能否站人
var overlapPos = collisionPoint + playerTransform.up * 0.2f;
PlayerEntityUtility.GetCapsule(player, overlapPos, out _capsuleBottom, out _capsuleUp,
out _capsuleRadius);
if (Physics.OverlapCapsule(_capsuleBottom, _capsuleUp, _capsuleRadius, UnityLayers.SceneCollidableLayerMask)
.Length > 0)
{
return;
}
_kind = kind = CheckClimbKindByDistance(distance, GenericActionKind.Climb50Cm, out yTranslateOffset);
_matchTarget = collisionPoint;
}
public static bool CheckLadderKind(PlayerEntity player, out LadderLocation location, bool considerDirection = false)
{
location = LadderLocation.Null;
var playerTransform = player.RootGo().transform;
var pos = playerTransform.position;
Vector3 capsuleBottom, capsuleUp;
float capsuleRadius;
PlayerEntityUtility.GetCapsule(player, pos, out capsuleBottom,
out capsuleUp, out capsuleRadius);
//DebugDraw.DebugWireSphere(capsuleBottom, Color.red, capsuleRadius);
var length = Physics.OverlapSphereNonAlloc(capsuleBottom, capsuleRadius, colliders, UnityLayers.ClimbLadderLayerMask);
if (length == 0)
{
return(false);
}
location = CheckLadderLocation(colliders, length, playerTransform, considerDirection);
return(location != LadderLocation.Null);
}
public override void DoAction(IEventArgs args)
{
PlayerEntity p = GetPlayerEntity(args);
if (p != null)
{
PlayerEntityUtility.SetActive(p, args.GetBool(enable), EActiveMask.DisableAction);
}
}
protected override void InitComponent(PlayerEntity player, IContexts contexts)
{
var character = DefaultGo.CreateGameObject(player.entityKey.ToString());
character.layer = UnityLayerManager.GetLayerIndex(EUnityLayerName.Player);
var cc = PlayerEntityUtility.InitCharacterController(character);
var kcc = PlayerEntityUtility.InitKinematicCharacterMotor(character);
var characterControllerContext = new CharacterControllerContext(
new UnityCharacterController(cc, ModelLoadHandler.InitActionWithOffset(), !player.isFlagSelf),
new ProneCharacterController(kcc,
new ProneController(), ModelLoadHandler.InitActionWithNoOffset()),
new DiveCharacterController(kcc,
new DiveController(), ModelLoadHandler.InitActionWithNoOffset()),
new SwimCharacterController(kcc,
new SwimController(), ModelLoadHandler.InitActionWithNoOffset())
);
var curver = character.AddComponent <AirMoveCurve>();
curver.AireMoveCurve = SingletonManager.Get <CharacterStateConfigManager>().AirMoveCurve;
character.AddComponent <EntityReference>();
character.GetComponent <EntityReference>().Init(player.entityAdapter);
var comp = character.AddComponent <PlayerVehicleCollision>();
comp.AllContext = contexts as Contexts;
var appearanceManager = new AppearanceManager();
var characterControllerManager = new CharacterControllerManager();
characterControllerManager.SetCharacterController(characterControllerContext);
var characterBone = new CharacterBoneManager();
characterBone.SetWardrobeController(appearanceManager.GetWardrobeController());
characterBone.SetWeaponController(appearanceManager.GetController <NewWeaponController>());
var weaponController = (NewWeaponController)appearanceManager.GetController <NewWeaponController>();
if (null != weaponController)
{
weaponController.SetWeaponChangedCallBack(characterBone.CurrentP1WeaponChanged, characterBone.CurrentP3WeaponChanged);
weaponController.SetWeaponOrAttachmentDeleteCallBack(characterBone.WeaponOrAttachmentDel);
weaponController.SetWeaponOrAttachementAddCallBack(characterBone.WeaponOrAttachmentAdd);
weaponController.SetCacheChangeAction(characterBone.CacheChangeCacheAction);
}
player.AddCharacterControllerInterface(characterControllerManager);
player.AddAppearanceInterface(appearanceManager);
player.AddCharacterContoller(characterControllerContext);
player.AddCharacterBoneInterface(characterBone);
player.AddPlayerGameState(PlayerLifeStateEnum.NullState);
player.AddPlayerResource(character);
}
private void UpdateBones(PlayerEntity player)
{
var orientation = player.orientation;
var networkAnimator = player.networkAnimator;
var characterBoneInterface = player.characterBoneInterface;
var thirdPersonAppearance = player.thirdPersonAppearance;
var characterBone = player.characterBone;
var characterControllerInterface = player.characterControllerInterface;
characterBoneInterface.CharacterBone.Peek(thirdPersonAppearance.PeekDegree);
try
{
_subCharacterBoneUpdateInfo.BeginProfileOnlyEnableProfile();
var param = new CodeRigBoneParam
{
PitchAmplitude = orientation.Pitch,
OverlayAnimationWeight = networkAnimator.AnimatorLayers[NetworkAnimatorLayer.PlayerUpperBodyOverlayLayer].Weight,
PostureWhenOverlay = thirdPersonAppearance.Posture,
// 预测时，IK不生效
IKActive = PlayerEntityUtility.ActiveIK(thirdPersonAppearance.Action,
thirdPersonAppearance.Posture, thirdPersonAppearance.NextPosture, thirdPersonAppearance.Movement),
HeadPitch = characterBone.PitchHeadAngle,
HeadYaw = characterBone.RotHeadAngle,
CurrentHandPitch = characterBone.CurrentPitchHandAngle,
WeaponRot = characterBone.WeaponRot,
FirstPersonPositionOffset = characterBone.FirstPersonPositionOffset,
FirstPersonRotationOffset = characterBone.FirstPersonRotationOffset,
FirstPersonSightOffset = characterBone.FirstPersonSightOffset
};
// code controlled pose
characterBoneInterface.CharacterBone.WeaponRotPlayback(param);
characterBoneInterface.CharacterBone.Update(param);
}
finally
{
_subCharacterBoneUpdateInfo.EndProfileOnlyEnableProfile();
}
try
{
_subCharacterControllerUpdateInfo.BeginProfileOnlyEnableProfile();
player.characterContoller.Value.SetCurrentControllerType(ThirdPersonPostureTool.ConvertToPostureInConfig(thirdPersonAppearance.Posture));
// 更新包围盒
if (thirdPersonAppearance.NeedUpdateController)
{
characterControllerInterface.CharacterController.SetCharacterControllerHeight(thirdPersonAppearance.CharacterHeight, player.characterContoller.Value.GetCurrentControllerType() == CharacterControllerType.UnityCharacterController, thirdPersonAppearance.CharacterStandHeight);
characterControllerInterface.CharacterController.SetCharacterControllerCenter(thirdPersonAppearance.CharacterCenter, player.characterContoller.Value.GetCurrentControllerType() == CharacterControllerType.UnityCharacterController);
characterControllerInterface.CharacterController.SetCharacterControllerRadius(thirdPersonAppearance.CharacterRadius, player.characterContoller.Value.GetCurrentControllerType() == CharacterControllerType.UnityCharacterController);
}
}
finally
{
_subCharacterControllerUpdateInfo.EndProfileOnlyEnableProfile();
}
}
private void P1ModelLoadSuccess(PlayerEntity player, UnityObject unityObj)
{
if (!player.hasEntityKey)
{
return;
}
_p1Objs[player.entityKey.Value.EntityId] = unityObj;
// 移除视野
PlayerEntityUtility.SetVisibility(unityObj.AsGameObject, false);
}
public Vector3?GetTopPos(long id)
{
foreach (PlayerEntity pe in _contexts.player.GetEntities())
{
if (pe.playerInfo.PlayerId == id)
{
return(PlayerEntityUtility.GetPlayerTopPosition(pe));
}
}
return(null);
}
public static bool IsPlayerOverlapAtPosition(PlayerEntity player, Vector3 position, int layerMask)
{
Vector3 p1, p2;
float radius;
PlayerEntityUtility.GetCapsule(player, position, out p1, out p2, out radius);
var colliders = Physics.OverlapCapsule(p1, p2, radius, layerMask);
return(colliders.Length > 0);
}
private static void CreateData(PlayerEntity player)
{
if (null == player)
{
return;
}
var playerTransform = player.RootGo().transform;
_overlapPos = playerTransform.position;
PlayerEntityUtility.GetCapsule(player, _overlapPos, out _capsuleBottom,
out _capsuleUp, out _capsuleRadius);
_capsuleHeight = _capsuleUp.y - _capsuleBottom.y;
_capsuleBottom.y = (playerTransform.position + playerTransform.up * 0.5f).y;
}
private static bool VaultUpTest(Vector3 collisionPoint, PlayerEntity player, out GenericActionKind kind,
out float yTranslateOffset)
{
_kind = kind = GenericActionKind.Null;
yTranslateOffset = 0.0f;
var playerTransform = player.RootGo().transform;
var distance = collisionPoint.y - playerTransform.position.y;
if (distance < MinVaultHeight || distance > MaxVaultHeight)
{
return(false);
}
// 检测翻越过程中障碍
var testPoint = new Vector3(playerTransform.position.x, collisionPoint.y, playerTransform.position.z);
_capsuleBottom = testPoint + playerTransform.up * 0.3f;
_capsuleUp = _capsuleBottom + playerTransform.up * 0.5f;
if (Physics.CapsuleCast(_capsuleBottom, _capsuleUp, 0.1f, _matchForward,
1, UnityLayers.SceneCollidableLayerMask))
{
return(false);
}
//
_overlapPos = playerTransform.position + _matchForward * (VaultPly + 2.0f * _capsuleRadius - PlayerEntityUtility.CcSkinWidth);
_overlapPos.y = (collisionPoint + -playerTransform.up * (VaultHeightLimit + 2 * PlayerEntityUtility.CcSkinWidth)).y;
PlayerEntityUtility.GetCapsule(player, _overlapPos, out _capsuleBottom, out _capsuleUp,
out _capsuleRadius);
// DebugDraw.DebugWireSphere(_overlapPos, Color.red, 0.4f, 10.0f);
// DebugDraw.DebugWireSphere(_capsuleBottom, Color.yellow, 0.4f, 10.0f);
// DebugDraw.DebugWireSphere(_capsuleUp, Color.yellow, 0.4f, 10.0f);
if (Physics.OverlapCapsule(_capsuleBottom, _capsuleUp, _capsuleRadius,
UnityLayers.SceneCollidableLayerMask).Length > 0)
{
return(false);
}
_kind = kind = CheckClimbKindByDistance(distance, GenericActionKind.Vault50Cm, out yTranslateOffset);
_matchTarget = collisionPoint;
return(true);
}
private static bool OverlapCapsuleTest(PlayerEntity playerEntity)
{
var gameObject = playerEntity.RootGo();
IntersectionDetectTool.SetColliderDisable(gameObject, IntersectionDetectTool.ColliderEnableState);
var overlapPos = gameObject.transform.position;
PlayerEntityUtility.GetCapsule(playerEntity, overlapPos, out _capsuleBottom, out _capsuleUp,
out _capsuleRadius);
var casts = Physics.OverlapCapsule(_capsuleBottom, _capsuleUp, _capsuleRadius,
UnityLayers.AllCollidableLayerMask);
IntersectionDetectTool.RestoreCollider(gameObject, IntersectionDetectTool.ColliderEnableState);
return(casts.Length > 0);
}
public void PlayPullBoltEffect(PlayerWeaponController controller)
{
if (null == controller)
{
Logger.Error("player state owner is not player or null !");
return;
}
var effectPos = PlayerEntityUtility.GetThrowingEmitPosition(controller);
float effectYaw = (controller.RelatedOrient.Yaw + 90) % 360;
float effectPitch = controller.RelatedOrient.Pitch;
int effectId = 32;
int effectTime = 3000;
ClientEffectFactory.CreateGrenadeExplosionEffect(_context, _idGenerator,
controller.Owner, effectPos, effectYaw, effectPitch, effectId, effectTime, EClientEffectType.PullBolt);
}
private void DoExplosionDamangeToPlayer(VehicleEntity explodedVehicle, Collider collider, Vector3 explosionCenter)
{
var player = PlayerEntityUtility.GetPlayerFromChildCollider(collider);
if (player == null || _processedEntities.Contains(player))
{
return;
}
_processedEntities.Add(player);
var damage = CalcExplosionDamageToPlayer(explodedVehicle, player, explosionCenter);
PlayerEntity sourcePlayer;
var damageType = GetDamageType(explodedVehicle, out sourcePlayer);
VehicleDamageUtility.DoPlayerDamage(sourcePlayer, player, damage, damageType);
}
private static bool OverlapCapsuleTest(PlayerEntity playerEntity)
{
var gameObject = playerEntity.RootGo();
var prevLayer = gameObject.layer;
IntersectionDetectTool.SetColliderLayer(gameObject, UnityLayerManager.GetLayerIndex(EUnityLayerName.User));
var overlapPos = gameObject.transform.position;
PlayerEntityUtility.GetCapsule(playerEntity, overlapPos, out _capsuleBottom, out _capsuleUp,
out _capsuleRadius);
var casts = Physics.OverlapCapsule(_capsuleBottom, _capsuleUp, _capsuleRadius,
UnityLayers.AllCollidableLayerMask);
IntersectionDetectTool.SetColliderLayer(gameObject, prevLayer);
return(casts.Length > 0);
}
private void RefreshThrowingData(PlayerEntity player)
{
ThrowingActionInfo actionInfo = player.throwingAction.ActionInfo;
var dir = BulletDirUtility.GetThrowingDir(player.WeaponController());
if (actionInfo.IsNearThrow)
{
actionInfo.Vel = dir * actionInfo.Config.NearInitSpeed;
}
else
{
actionInfo.Vel = dir * actionInfo.Config.FarInitSpeed;
}
actionInfo.Pos = PlayerEntityUtility.GetThrowingEmitPosition(player.WeaponController());
actionInfo.Gravity = actionInfo.Config.Gravity;
actionInfo.Decay = actionInfo.Config.VelocityDecay;
actionInfo.CountdownTime = actionInfo.Config.CountdownTime;
}
public void PlayPullBoltEffect(IPlayerWeaponState playerState)
{
var player = playerState.Owner as PlayerEntity;
if (null == player)
{
Logger.Error("player state owner is not player or null !");
return;
}
var owner = player.entityKey.Value;
var effectPos = PlayerEntityUtility.GetThrowingEmitPosition(player);
float effectYaw = (playerState.ViewYaw + 90) % 360;
float effectPitch = playerState.ViewPitch;
int effectId = 32;
int effectTime = 3000;
ClientEffectFactory.CreateGrenadeExplosionEffect(_context, _idGenerator,
owner, effectPos, effectYaw, effectPitch, effectId, effectTime, EClientEffectType.PullBolt);
}
public override void RecoverHitBox(IGameEntity gameEntity, int renderTime)
{
var playerEntity = GetPlayerEntity(gameEntity);
var hitBoxComponent = GetHitBoxComponent(playerEntity);
if (hitBoxComponent != null)
{
if (playerEntity.hitBox.RenderTime != renderTime)
{
playerEntity.RootGo().transform.SetPositionAndRotation(playerEntity.position.Value, playerEntity.orientation.ModelView);
PlayerEntityUtility.UpdateTransform(playerEntity, playerEntity.networkAnimator,
playerEntity.predictedAppearance, playerEntity.orientation);
playerEntity.thirdPersonAnimator.UnityAnimator.cullingMode =
AnimatorCullingMode.CullUpdateTransforms;
playerEntity.hitBox.RenderTime = renderTime;
}
}
base.RecoverHitBox(gameEntity, renderTime);
}
private void StartFlying(PlayerEntity playerEntity, ThrowingEntity throwingEntity)
{
var dir = BulletDirUtility.GetThrowingDir(playerEntity.WeaponController());
Vector3 vel = dir * throwingEntity.throwingData.InitVelocity;
Vector3 pos = PlayerEntityUtility.GetThrowingEmitPosition(playerEntity.WeaponController());
throwingEntity.position.Value = pos;
throwingEntity.throwingData.Velocity = vel;
throwingEntity.throwingData.IsFly = true;
if (SharedConfig.IsServer)
{
IEventArgs args = (IEventArgs)_contexts.session.commonSession.FreeArgs;
if (!args.Triggers.IsEmpty((int)EGameEvent.WeaponState))
{
SimpleParaList dama = new SimpleParaList();
//TODO 确认逻辑
dama.AddFields(new ObjectFields(playerEntity));
var weaponData = playerEntity.WeaponController().HeldWeaponAgent.ComponentScan;
if (!weaponData.IsSafeVailed)
{
return;
}
dama.AddPara(new IntPara("CarryClip", playerEntity.WeaponController().GetReservedBullet()));
dama.AddPara(new IntPara("Clip", weaponData.Bullet));
var config = SingletonManager.Get <WeaponResourceConfigManager>().GetConfigById(weaponData.ConfigId);
dama.AddPara(new IntPara("ClipType", null == config ? 0 : config.Caliber));
dama.AddPara(new IntPara("id", weaponData.ConfigId));
SimpleParable sp = new SimpleParable(dama);
args.Trigger((int)EGameEvent.WeaponState, new TempUnit("state", sp), new TempUnit("current", (FreeData)(playerEntity).freeData.FreeData));
}
}
//清理状态
CastGrenade(_contexts, playerEntity);
}
// Vault测试需在Step测试之前
private static bool VaultUpTest(Vector3 collisionPoint, PlayerEntity player, out GenericActionKind kind, out Vector3 matchTarget)
{
kind = GenericActionKind.Null;
matchTarget = Vector3.zero;
var playerTransform = player.RootGo().transform;
var distance = collisionPoint.y - playerTransform.position.y;
if (distance < 0.8 || distance > 2.3)
{
return(false);
}
// 检测翻越过程中障碍
_capsuleBottom.y = (collisionPoint + playerTransform.up * 0.3f).y;
_capsuleUp.y = _capsuleBottom.y + _capsuleHeight;
if (Physics.CapsuleCast(_capsuleBottom, _capsuleUp, 0.1f, playerTransform.forward,
1, UnityLayers.SceneCollidableLayerMask))
{
return(false);
}
// 人物当前位置，往前移动1m，往上移动0.2m
_overlapPos = playerTransform.position + playerTransform.forward * (1.0f + _capsuleRadius) +
playerTransform.up * 0.2f;
PlayerEntityUtility.GetCapsule(player, _overlapPos, out _capsuleBottom, out _capsuleUp,
out _capsuleRadius);
if (Physics.OverlapCapsule(_capsuleBottom, _capsuleUp, _capsuleRadius,
UnityLayers.SceneCollidableLayerMask).Length > 0)
{
return(false);
}
kind = GenericActionKind.Vault;
matchTarget = collisionPoint - playerTransform.right * 0.2f;
return(true);
}
public void OnLoadSucc(PlayerEntity player, UnityObject unityObj)
{
if (null == unityObj || null == unityObj.AsGameObject)
{
Logger.ErrorFormat("CharacterLog-- playerEntity: {0} unityObj is Null", player.entityKey);
}
GameObject go = unityObj;
if (player.hasThirdPersonModel)
{
_assetManager.Recycle(player.thirdPersonModel.UnityObjectValue);
player.RemoveAsset(player.thirdPersonModel.UnityObjectValue);
}
player.ReplaceThirdPersonModel(go, unityObj);
var provider = SingletonManager.Get <HitBoxTransformProviderCache>()
.GetProvider(player.thirdPersonModel.Value);
HitBoxComponentUtility.InitHitBoxComponent(player.entityKey.Value, player, provider);
RemoveRagdollOnServerSide(go, provider.GetHitBoxColliders().Values.ToList());
HandleLoadedModel(player, go);
InitCharacterControllerSetting(player);
player.AddAsset(unityObj);
go.name = go.name.Replace("(Clone)", "");
go.transform.SetParent(GetThirdModelParent(player.RootGo().transform));
go.transform.localPosition = new Vector3(0, 0, 0);
go.transform.localRotation = Quaternion.identity;
go.transform.localScale = Vector3.one;
Logger.InfoFormat("CharacterLog-- P3 loaded: {0}", player.entityKey);
BoneTool.CacheTransform(go);
player.ReplaceBones(null, null, null);
player.bones.Head = BoneMount.FindChildBoneFromCache(go, BoneName.CharacterHeadBoneName);
player.bones.Spine = BoneMount.FindChildBoneFromCache(go, BoneName.CharacterSpineName);
player.ReplaceThirdPersonAnimator(go.GetComponent <Animator>());
if (player.hasFsmInputRelateInterface)
{
player.fsmInputRelateInterface.Relate.InitLimit();
player.fsmInputRelateInterface.Relate.CreateAllLimitFsmInput(player.thirdPersonAnimator.UnityAnimator);
}
var ik = go.AddComponent <PlayerIK>();
ik.SetAnimator(AvatarIKGoal.LeftHand, player.thirdPersonAnimator.UnityAnimator);
ik.SetIKLayer(AvatarIKGoal.LeftHand, NetworkAnimatorLayer.ThirdPersonIKPassLayer);
ik.SetAnimator(AvatarIKGoal.RightHand, player.thirdPersonAnimator.UnityAnimator);
ik.SetIKLayer(AvatarIKGoal.RightHand, NetworkAnimatorLayer.ThirdPersonIKPassLayer);
if (player.isFlagSelf)
{
var animationEvent = go.AddComponent <AnimationClipEvent>();
animationEvent.Player = player;
player.animatorClip.ClipManager.SetAnimationCleanEventCallback(animationEvent
.InterruptAnimationEventFunc);
}
else
{
go.AddComponent <ThirdPersonAnimationClipEvent>();
}
// 设置大厅传入的roleId和avatarId
player.appearanceInterface.Appearance.SetRoleModelIdAndInitAvatar(player.playerInfo.RoleModelId,
player.playerInfo.AvatarIds);
player.characterControllerInterface.CharacterController.SetCharacterRoot(player.characterContoller.Value
.gameObject);
player.appearanceInterface.Appearance.SetRootGo(player.RootGo());
player.appearanceInterface.Appearance.SetThirdPersonCharacter(go);
player.appearanceInterface.Appearance.SetRagDollComponent(player.ragDoll);
player.characterControllerInterface.CharacterController.SetThirdModel(player.thirdPersonModel.Value);
player.characterBoneInterface.CharacterBone.SetCharacterRoot(player.characterContoller.Value
.gameObject);
player.characterBoneInterface.CharacterBone.SetThirdPersonCharacter(go);
ForceCrouch(player.thirdPersonAnimator.UnityAnimator);
player.characterBoneInterface.CharacterBone.SetStableCrouchPelvisRotation();
ForceStand(player.thirdPersonAnimator.UnityAnimator);
player.characterBoneInterface.CharacterBone.SetStableStandPelvisRotation();
player.appearanceInterface.Appearance.SetAnimatorP3(player.thirdPersonAnimator.UnityAnimator);
player.appearanceInterface.Appearance.PlayerReborn();
player.characterControllerInterface.CharacterController.PlayerReborn();
if (player.hasStateInterface)
{
player.stateInterface.State.PlayerReborn();
}
if (player.hasPlayerInfo)
{
player.playerInfo.InitTransform();
}
player.ReplaceNetworkAnimator(
NetworkAnimatorUtil.CreateAnimatorLayers(player.thirdPersonAnimator.UnityAnimator),
NetworkAnimatorUtil.GetAnimatorParams(player.thirdPersonAnimator.UnityAnimator));
player.networkAnimator.SetEntityName(player.entityKey.ToString());
player.ReplaceOverrideNetworkAnimator();
if (SharedConfig.IsServer)
{
player.ReplaceNetworkAnimatiorServerTime(0);
}
// 禁用非可见状态下的动画更新，在获取Stable状态之后
if (SharedConfig.IsServer || !player.isFlagSelf)
{
player.thirdPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.CullUpdateTransforms;
}
else
{
player.thirdPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
}
//人物变身、换肤时，清空特效数据
if (player.hasEffects)
{
player.effects.ResetEffects();
}
// 处理显隐
if (player.hasGamePlay)
{
PlayerEntityUtility.SetVisibility(go, player.gamePlay.Visibility);
}
}
public void Update(EntityKey ownerKey, int frameTime)
{
_allThrowingSegments.Clear();
foreach (ThrowingEntity throwing in _throwings.GetEntities())
{
if (throwing.ownerId.Value != ownerKey)
{
CheckVisible(throwing);
continue;
}
if (throwing.isFlagDestroy)
{
continue;
}
PlayerEntity player = _contexts.player.GetEntityWithEntityKey(throwing.ownerId.Value);
//销毁被中断的手雷
if (null != player && player.throwingAction.ActionInfo.IsInterrupt &&
player.throwingAction.ActionInfo.ThrowingEntityKey == throwing.entityKey.Value)
{
player.throwingAction.ActionInfo.IsInterrupt = false;
throwing.isFlagDestroy = true;
continue;
}
if (throwing.hasLifeTime && (DateTime.Now - throwing.lifeTime.CreateTime).TotalMilliseconds > throwing.throwingData.Config.CountdownTime)
{
//爆炸
ExplosionEffect(throwing);
//伤害
if (SharedConfig.IsOffline || SharedConfig.IsServer)
{
BombingHandler(throwing);
}
throwing.isFlagDestroy = true;
if (!throwing.throwingData.IsFly)
{
player.stateInterface.State.FinishGrenadeThrow();
CastGrenade(player);
}
continue;
}
if (throwing.throwingData.IsThrow &&
!throwing.throwingData.IsFly &&
null != player &&
player.throwingUpdate.IsStartFly &&
!throwing.isFlagDestroy)
{
//开始飞出
StartFlying(player, throwing);
}
if (throwing.throwingData.IsFly)
{
CheckVisible(throwing);
bool isInWater = throwing.throwingData.IsInWater;
var segments = _moveSimulator.MoveThrowing(throwing, frameTime);
if (null != segments)
{
_allThrowingSegments.AddRange(segments);
}
//入水特效
throwing.throwingData.IsInWater = SingletonManager.Get <MapConfigManager>().InWater(throwing.position.Value);
if (!isInWater && throwing.throwingData.IsInWater)
{
PlayOneEffect(throwing, throwing.throwingData.Config.EnterWaterEffectId, throwing.position.Value, false);
}
}
else if (null != player)
{
Vector3 pos = PlayerEntityUtility.GetHandWeaponPosition(player);
throwing.position.Value = pos;
}
}
_allThrowingSegments.Sort(_comparator);
if (_newRaycast)
{
NewRaycast();
}
else
{
OldRaycast();
}
}
public static bool GetRideOffPosition(PlayerEntity playerEntity, VehicleEntity vehicleEntity, Vector3 direction, out Vector3 resolvedPosition, float liftHeight = 0.01f, float displacement = 0.05f)
{
var character = playerEntity.RootGo();
const float sweepDistance = 5.0f;
direction = -direction;
var p = character.transform.position - direction * sweepDistance;
Vector3 p1, p2;
float radius;
PlayerEntityUtility.GetCapsule(playerEntity, p, out p1, out p2, out radius);
vehicleEntity.SetLayer(UnityLayerManager.GetLayerIndex(EUnityLayerName.User));
resolvedPosition = character.transform.position;
var hit = new RaycastHit();
var hitDist = 2.0f;
var lowOffset = new Vector3(0, -0.5f, 0);
if (Physics.CapsuleCast(p1, p2, radius, direction, out hit, sweepDistance, UnityLayerManager.GetLayerMask(EUnityLayerName.User)) ||
//the seat position may be higher than the vehicle's height, then low the position to get collided position
Physics.CapsuleCast(p1 + lowOffset, p2 + lowOffset, radius, direction, out hit, sweepDistance, UnityLayerManager.GetLayerMask(EUnityLayerName.User)))
{
hitDist = hit.distance;
}
{
var distance = (hitDist - displacement) * direction;
var colliders = Physics.OverlapCapsule(p1 + distance, p2 + distance, radius);
if (colliders.Length > 0)
{
vehicleEntity.SetLayer(UnityLayerManager.GetLayerIndex(EUnityLayerName.Vehicle));
return(false);
}
var disp = direction * (hitDist - displacement - sweepDistance);
var position = resolvedPosition;
position += disp;
if (liftHeight > 0.0f)
{
RaycastHit upHit;;
Physics.CapsuleCast(p1 + disp, p2 + disp, radius, Vector3.up, out upHit, liftHeight);
position += upHit.distance * Vector3.up;
}
var dist = resolvedPosition - position;
var ray = new Ray(position, dist.normalized);
if (Physics.Raycast(ray, out hit, dist.magnitude, UnityLayers.AllCollidableLayerMask))
{
vehicleEntity.SetLayer(UnityLayerManager.GetLayerIndex(EUnityLayerName.Vehicle));
return(false);
}
resolvedPosition = position;
}
vehicleEntity.SetLayer(UnityLayerManager.GetLayerIndex(EUnityLayerName.Vehicle));
return(true);
}
protected void HandleLoadedModel(PlayerEntity player, GameObject obj)
{
obj.layer = UnityLayerManager.GetLayerIndex(EUnityLayerName.Player);
PlayerEntityUtility.DisableCollider(obj.transform);
if (!player.hasCharacterContoller)
{
var character = DefaultGo.CreateGameObject(player.entityKey.ToString());
character.layer = UnityLayerManager.GetLayerIndex(EUnityLayerName.Player);
AddThirdModelOffsetObject(character);
CharacterController cc = PlayerEntityUtility.InitCharacterController(character);
KinematicCharacterMotor kcc = PlayerEntityUtility.InitKinematicCharacterMotor(character);
CharacterControllerContext characterControllerContext = new CharacterControllerContext(
new UnityCharacterController(cc, InitActionWithOffset(), !player.isFlagSelf),
new Core.CharacterController.ConcreteController.ProneCharacterController(kcc,
new ProneController(),
InitActionWithNoOffset()),
new Core.CharacterController.ConcreteController.DiveCharacterController(kcc,
new DiveController(), InitActionWithNoOffset()),
new Core.CharacterController.ConcreteController.SwimCharacterController(kcc,
new SwimController(), InitActionWithNoOffset())
);
var curver = character.AddComponent <AirMoveCurve>();
curver.AireMoveCurve = SingletonManager.Get <CharacterStateConfigManager>().AirMoveCurve;
curver.MovementCurve = SingletonManager.Get <CharacterStateConfigManager>().MovementCurve;
curver.PostureCurve = SingletonManager.Get <CharacterStateConfigManager>().PostureCurve;
if (character.GetComponent <EntityReference>() == null)
{
character.AddComponentUncheckRequireAndDisallowMulti <EntityReference>();
}
character.GetComponent <EntityReference>().Init(player.entityAdapter);
var comp = character.AddComponent <PlayerVehicleCollision>();
comp.AllContext = _contexts;
var appearanceManager = new AppearanceManager();
var characterControllerManager = new CharacterControllerManager();
characterControllerManager.SetCharacterController(characterControllerContext);
var characterBone = new CharacterBoneManager();
characterBone.SetWardrobeController(appearanceManager.GetWardrobeController());
characterBone.SetWeaponController(appearanceManager.GetController <WeaponController>());
var weaponController = (WeaponController)appearanceManager.GetController <WeaponController>();
if (null != weaponController)
{
weaponController.SetWeaponChangedCallBack(characterBone.CurrentWeaponChanged);
weaponController.SetCacheChangeAction(characterBone.CacheChangeCacheAction);
}
player.AddCharacterControllerInterface(characterControllerManager);
player.AddAppearanceInterface(appearanceManager);
player.AddCharacterContoller(characterControllerContext);
player.AddCharacterBoneInterface(characterBone);
player.AddRecycleableAsset(character);
player.AddPlayerGameState(PlayerLifeStateEnum.NullState);
}
}
public void OnLoadSucc(PlayerEntity player, UnityObject unityObj)
{
GameObject go = unityObj;
HandleLoadedModel(player, go);
if (player.hasFirstPersonModel)
{
_assetManager.Recycle(player.firstPersonModel.UnityObjectValue);
player.RemoveAsset(player.firstPersonModel.UnityObjectValue);
}
player.ReplaceFirstPersonModel(go, unityObj);
player.AddAsset(unityObj);
player.appearanceInterface.FirstPersonAppearance =
new FirstPersonAppearanceManager(player.firstPersonAppearance);
go.name = "P1_" + player.entityKey;
go.transform.SetParent(player.RootGo().transform);
go.transform.localPosition = new Vector3(0, player.firstPersonAppearance.FirstPersonHeight,
player.firstPersonAppearance.FirstPersonForwardOffset);
go.transform.localRotation = Quaternion.identity;
go.transform.localScale = Vector3.one;
Logger.InfoFormat("P1 loaded: {0}", player.entityKey);
player.ReplaceFirstPersonAnimator(go.GetComponent <Animator>());
var ik = go.AddComponent <PlayerIK>();
ik.SetAnimator(AvatarIKGoal.LeftHand, player.firstPersonAnimator.UnityAnimator);
ik.SetIKLayer(AvatarIKGoal.LeftHand, NetworkAnimatorLayer.FirstPersonIKPassLayer);
ik.SetAnimator(AvatarIKGoal.RightHand, player.firstPersonAnimator.UnityAnimator);
ik.SetIKLayer(AvatarIKGoal.RightHand, NetworkAnimatorLayer.FirstPersonIKPassLayer);
BoneTool.CacheTransform(go);
if (player.isFlagSelf)
{
var animationEvent = go.AddComponent <AnimationClipEvent>();
animationEvent.Player = player;
player.animatorClip.ClipManager.SetAnimationCleanEventCallback(animationEvent
.InterruptAnimationEventFunc);
}
else
{
go.AddComponent <ThirdPersonAnimationClipEvent>();
}
player.firstPersonAnimator.UnityAnimator.Update(0);
player.appearanceInterface.Appearance.SetRootGo(player.RootGo());
player.appearanceInterface.Appearance.SetFirstPersonCharacter(go);
player.appearanceInterface.FirstPersonAppearance.SetFirstPersonCharacter(go);
player.appearanceInterface.Appearance.SetAnimatorP1(player.firstPersonAnimator.UnityAnimator);
player.stateInterface.State.SetName(player.RootGo().name);
player.characterBoneInterface.CharacterBone.SetFirstPersonCharacter(go);
player.ReplaceFpAnimStatus(
NetworkAnimatorUtil.CreateAnimatorLayers(player.firstPersonAnimator.UnityAnimator),
NetworkAnimatorUtil.GetAnimatorParams(player.firstPersonAnimator.UnityAnimator));
// 禁用非可见状态下的动画更新
if (!player.isFlagSelf)
{
player.firstPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.CullUpdateTransforms;
}
else
{
player.firstPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
}
var playerUtils = GameObject.Instantiate(Resources.Load <GameObject>("PlayerUtils"));
EffectUtility.RegistEffect(player.RootGo().gameObject, playerUtils);
playerUtils.transform.parent = EffectUtility.GetEffectNode(player.RootGo());
// 处理显隐
if (player.hasGamePlay)
{
PlayerEntityUtility.SetVisibility(go, player.gamePlay.Visibility);
}
}
protected override void ExecuteUserCmd(PlayerEntity player, IUserCmd cmd)
{
if (player.time.ClientTime < player.meleeAttackInfoSync.AttackTime)
{
return;
}
// Logger.Info("Try Attack One Time, Interval:"+ (player.meleeAttackInfoSync.AttackTime - player.meleeAttackInfoSync.BeforeAttackTime));
// Logger.Info("Try Attack One Time, Interval:"+ (player.time.ClientTime - player.meleeAttackInfoSync.BeforeAttackTime));
var config = player.meleeAttackInfo.AttackConfig;
if (null == config)
{
Logger.Error("attack info in player MeleeAttackInfo is null");
return;
}
var attackInfo = player.meleeAttackInfo.AttackInfo;
player.RemoveMeleeAttackInfoSync();
var compensationWorld = _compensationWorldFactory.CreateCompensationWorld(cmd.RenderTime);
if (null == compensationWorld)
{
Logger.ErrorFormat("CompensationWorld is null for time {0}", cmd.RenderTime);
return;
}
compensationWorld.Self = player.entityKey.Value;
compensationWorld.ExcludePlayerList =
player.playerHitMaskController.HitMaskController.MeleeExcludeTargetList;
Quaternion rotation;
player.TryGetMeleeAttackRotation(out rotation);
RaycastHit hit;
//小于这个距离没有检测,设一个足够小的值
var minDistance = 0.01f;
var extens = new Vector3(config.Width, config.Height, minDistance);
Vector3 emitPos;
if (!PlayerEntityUtility.TryGetMeleeAttackPosition(player, out emitPos))
{
Logger.Error("get melee attack position failed ");
emitPos = player.position.Value + Vector3.up * MeleeHitUtil.GetDefaultHeight(player);
}
var box = new BoxInfo
{
Length = config.Range,
Direction = rotation.Forward(),
Origin = emitPos,
Orientation = rotation,
HalfExtens = extens / 2f,
};
if (compensationWorld.BoxCast(box, out hit, BulletLayers.GetBulletLayerMask()))
{
PlayerEntity targetPlayer = null;
VehicleEntity targetVehicle = null;
var comp = hit.collider.transform.gameObject.GetComponent <HitBoxOwnerComponent>();
if (comp != null)
{
targetPlayer = _contexts.player.GetEntityWithEntityKey(comp.OwnerEntityKey);
targetVehicle = _contexts.vehicle.GetEntityWithEntityKey(comp.OwnerEntityKey);
}
if (targetPlayer != null)
{
hitHandler.OnHitPlayer(_contexts, player, targetPlayer, hit, attackInfo, config, cmd.Seq);
}
else if (targetVehicle != null)
{
hitHandler.OnHitVehicle(_contexts, player, targetVehicle, hit, attackInfo, config);
}
else
{
hitHandler.OnHitEnvrionment(_contexts, player, hit, attackInfo, config);
}
}
compensationWorld.Release();
// Logger.Info("Try Attack Finish");
}
/**
* 1.人物正前方做CapsuleCast(capsuleBottom向上微抬)
* 2.hit点向上抬 探出碰撞体高 + 人物高 的距离
* 3.向下做SphereCast(半径0.3)，目的是人物所站位置与攀爬位置有一定的容错
* 4.hit点作为攀爬点，做MatchTarget(手到hit点差值)
* 5.人物站立位置往正前方移动1m，做OverlapCapsule，检测翻越
*/
private void TestTrigger(PlayerEntity player)
{
var playerTransform = player.RootGo().transform;
RaycastHit hit;
var overlapPos = playerTransform.position;
PlayerEntityUtility.GetCapsule(player, overlapPos, out _capsuleBottom, out _capsuleUp, out _capsuleRadius);
var capsuleHight = _capsuleUp.y - _capsuleBottom.y;
_capsuleBottom.y = (playerTransform.position + playerTransform.up * 0.5f).y;
if ((null == _concretAction || !_concretAction.PlayingAnimation) &&
Physics.CapsuleCast(_capsuleBottom, _capsuleUp, 0.001f, playerTransform.forward, out hit, 1,
UnityLayers.SceneCollidableLayerMask))
{
//如果碰撞点到发射点的距离大于0.5
if (hit.distance < 0.5)
{
//得到碰撞点
Vector3 point = hit.point;
Vector3 sphereCenter = new Vector3(hit.point.x, hit.collider.bounds.center.y + hit.collider.bounds.extents.y + capsuleHight, hit.point.z);
// 检测发射源是否处于碰撞体中
if (Physics.OverlapSphere(sphereCenter, 0.3f, UnityLayers.SceneCollidableLayerMask).Length >
0)
{
return;
}
RaycastHit sphereHit;
Physics.SphereCast(sphereCenter, 0.3f, Vector3.down, out sphereHit,
hit.collider.bounds.center.y + hit.collider.bounds.extents.y + capsuleHight,
UnityLayers.SceneCollidableLayerMask);
point = sphereHit.point;
var distance = point.y - playerTransform.position.y;
if (distance > 1.5 && distance < 2.3)
{
//一定高度内为climb
ResetConcretAction();
_concretAction = _climbAction;
_concretAction.MatchTarget = point;
_concretAction.CanTriggerAction = true;
}
else if (distance > 0.5 && distance <= 1.5)
{
ResetConcretAction();
//
overlapPos = playerTransform.position + playerTransform.forward * (1.0f + _capsuleRadius) + playerTransform.up * 0.2f;
PlayerEntityUtility.GetCapsule(player, overlapPos, out _capsuleBottom, out _capsuleUp, out _capsuleRadius);
var casts = Physics.OverlapCapsule(_capsuleBottom, _capsuleUp, _capsuleRadius, UnityLayers.SceneCollidableLayerMask);
//
if (casts.Length <= 0 && distance > 0.8f)
{
_concretAction = _vaultAction;
}
else
{
_concretAction = _stepAction;
}
_concretAction.MatchTarget = point;
_concretAction.CanTriggerAction = true;
}
}
else
{
ResetConcretAction();
}
}
else
{//没有探测到障碍物
ResetConcretAction();
}
}
