public void SetPlayerDamageInfo(PlayerEntity source, PlayerEntity target, float damage, EBodyPart part)
{
if (Logger.IsDebugEnabled)
{
Logger.DebugFormat("SetPlayerDamageInfo {0} in {1}", damage, part);
}
var myPlayerEntity = _playerContext.flagSelfEntity;
if (source != myPlayerEntity)
{
if (Logger.IsDebugEnabled)
{
Logger.DebugFormat("source is not myself diff {0} {1}", source.entityKey.Value, myPlayerEntity.entityKey.Value);
}
return;
}
if (!myPlayerEntity.hasAttackDamage)
{
myPlayerEntity.AddAttackDamage(part, damage);
}
else
{
myPlayerEntity.attackDamage.HitPart = part;
myPlayerEntity.attackDamage.Damage = damage;
}
}
public int Play(int soundId)
{
if (Logger.IsDebugEnabled)
{
Logger.DebugFormat("play {0}", soundId);
}
if (null == _playerEntity)
{
return(UniversalConsts.InvalidIntId);
}
var soundConfigItem = _soundConfigManager.GetSoundById(soundId);
if (null == soundConfigItem)
{
return(UniversalConsts.InvalidIntId);
}
var entity = soundConfigItem.Sync ?
_soundEntityFactory.CreateSyncSound(_playerEntity, soundConfigItem, true) :
_soundEntityFactory.CreateSelfOnlySound(soundConfigItem.Id,
_playerEntity.position.Value,
true);
var soundEntity = entity as SoundEntity;
if (null == soundEntity)
{
return(UniversalConsts.InvalidIntId);
}
return(soundEntity.entityKey.Value.EntityId);
}
private void ShowOne(Map2D <GameObject> map, int index, bool show, string type)
{
int x = index / MaxLen;
int y = index % MaxLen;
//GameObject root = roots[x * MaxLen + y];
if (show)
{
//LinkedList<GameObject> list = map.Get(x, y);
//if (list != null && list.Count > 0)
//{
// StaticBatchingUtility.Combine(list.ToArray(), root);
//}
int count = map.HandleCell(x, y, ShowGameObject);
//root.SetActive(true);
if (count > 10)
{
_logger.DebugFormat("culling show {0},{1} count={2}, type={3}", x, y, count, type);
}
}
else
{
int count = map.HandleCell(x, y, HideGameObject);
//root.SetActive(false);
if (count > 10)
{
_logger.DebugFormat("culling hide {0},{1} count={2}, type={3}", x, y, count, type);
}
}
}
private void PutOn(GameObject go, int type, bool isSkinned, bool needMapping)
{
if (null != go)
{
if (isSkinned)
{
go.transform.SetParent(_characterGameObject.transform, false);
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
// go.transform.localScale = Vector3.one;
var allWardrobeBones = go.GetComponentsInChildren <Transform>();
_allAvatarBones[(Wardrobe)type] = allWardrobeBones;
foreach (var renderer in go.GetComponentsInChildren <SkinnedMeshRenderer>())
{
// 映射装扮与人物骨骼
if (needMapping)
{
var wardrobeBones = GetBonesOfTheSameName(renderer.bones, allWardrobeBones);
MappingBones(wardrobeBones, type);
}
renderer.bones = GetBonesOfTheSameName(renderer.bones, _allBones);
renderer.rootBone = GetBoneOfTheSameName(renderer.rootBone, _allBones);
}
}
else
{
_mount.MountWardrobe(go, _characterGameObject);
}
Logger.DebugFormat("SureAddWardrobe: {0}", go.name);
}
}
protected override void ExecuteUserCmd(PlayerEntity playerEntity, IUserCmd cmd)
{
if (!cmd.IsSprayPaint)
{
isSprayPainting = false;
return;
}
if (isSprayPainting)
{
return;
}
isSprayPainting = true;
var root = _contexts.player.flagSelfEntity.RootGo();
Transform cameraTran = _contexts.player.cameraObj.MainCamera.transform;
Transform headTran = BoneMount.FindChildBoneFromCache(root, BoneName.CharacterHeadBoneName); /*头部*/
if (headTran == null || cameraTran == null)
{
_logger.DebugFormat("error headTran or cameraTran !");
return;
}
Vector3 forward = cameraTran.forward;
Vector3 head = root.transform.eulerAngles;
var paintIdList = _contexts.ui.uI.PaintIdList;
var selectedPaintIndex = _contexts.ui.uI.SelectedPaintIndex;
if (0 == selectedPaintIndex)
{
selectedPaintIndex = PaintUiAdapter.SelectValidIndex(paintIdList);
_contexts.ui.uI.SelectedPaintIndex = selectedPaintIndex;
}
if (paintIdList == null || paintIdList.Count <= selectedPaintIndex || paintIdList[selectedPaintIndex] == 0)
{
_logger.DebugFormat("error paintIdList or selectedPaintIndex : " + selectedPaintIndex);
//TODO 未装备喷漆提示
return;
}
try
{
PlaySprayAudio();
}
catch (Exception e)
{
_logger.DebugFormat(e.Message);
}
RaycastHit raycastHit;
Ray ray = new Ray(headTran.position, cameraTran.forward);
if (Physics.Raycast(ray, out raycastHit, 3.0f))
{
if (!IsIgnore(raycastHit.collider.gameObject))
{
_logger.DebugFormat("SendSprayMessage");
SendMarkMessage(raycastHit.point, raycastHit.normal, head, paintIdList[selectedPaintIndex]);
}
}
}
public void UpdateHitBox(IGameEntity gameEntity)
{
var position = gameEntity.Position.Value;
var rotation = gameEntity.GetComponent <OrientationComponent>().RotationYaw;
var hitBoxComponent = GetHitBoxComponent(gameEntity.EntityKey);
if (hitBoxComponent != null)
{
hitBoxComponent.HitBoxGameObject.transform.position = position;
hitBoxComponent.HitBoxGameObject.transform.rotation = rotation;
var playerEntity = GetPlayerEntity(gameEntity);
playerEntity.thirdPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
var provider = SingletonManager.Get <HitBoxTransformProviderCache>().GetProvider(playerEntity.thirdPersonModel.Value);
provider.Update(position, rotation);
HitBoxGameObjectUpdater.Update(hitBoxComponent.HitBoxGameObject.transform, provider);
playerEntity.thirdPersonAnimator.UnityAnimator.cullingMode = AnimatorCullingMode.CullUpdateTransforms;
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("client animator {0}", playerEntity.networkAnimator.ToStringExt());
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 static int ShiftStreamingChilds(Vector3 diff)
{
int ret = 0;
int count = DefaultGo.StreamingRoot.transform.childCount;
for (int i = 0; i < count; i++)
{
try
{
var child = DefaultGo.StreamingRoot.transform.GetChild(i);
if (child.gameObject.activeSelf)
{
var localPosition = child.localPosition;
child.localPosition = localPosition + diff;
ret++;
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("move stream {0} {3} from {1} to {1}", child.name,
child.GetInstanceID(), localPosition,
child.localPosition);
}
}
}
catch (Exception e)
{
_logger.ErrorFormat("ShiftStreamingChilds :{0}{1} ", i, e);
}
}
return(ret);
}
public StreamSceneObjectAssetPostProcessor(UnityObject unityObject)
{
mrs.Clear();
trs.Clear();
i = unityObject.AsGameObject.GetInstanceID();
_logger.DebugFormat("StreamSceneObjectAssetPostProcessor :{0}", i);
// record origin state info
GameObject go = unityObject.AsGameObject;
go.GetComponentsInChildren <MeshRenderer>(true, mrs);
go.GetComponentsInChildren <Transform>(true, trs);
originShadows = new Dictionary <int, ShadowCastingMode>(mrs.Count);
originLightProbes = new Dictionary <int, LightProbeUsage>(mrs.Count);
originStatus = new Dictionary <int, bool>(trs.Count);
foreach (MeshRenderer mr in mrs)
{
if (mr != null)
{
int id = mr.GetInstanceID();
originShadows.Add(id, mr.shadowCastingMode);
originLightProbes.Add(id, mr.lightProbeUsage);
}
}
foreach (Transform tr in trs)
{
if (tr != null)
{
int id = tr.GetInstanceID();
originStatus.Add(id, tr.gameObject.activeSelf);
}
}
}
public void Update()
{
var objs = _deactiveMapObjects.GetEntities();
for (int i = 0; i < objs.Length; ++i)
{
var obj = objs[i];
var id = obj.triggerObjectId.Id;
var go = GetTriggerObject(id);
if (go != null)
{
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Trigger Object: Type {0} id {1} Loaded On Update Self Position {2}.", _triggerType, id, _contexts.player.flagSelfEntity.position.Value);
}
OnDeativeObjectActive(id, obj, go);
}
}
if (_deactiveMapObjects.Any())
{
_logger.DebugFormat("Waiting For Trigger Object Loading: Type {0} Count {1}", _triggerType, _deactiveMapObjects.Count());
}
}
public void DoReceived(MemoryStream stream)
{
var buffer = stream.GetBuffer();
int messageType = LittleEndian
? BitConverter.ToInt32(stream.GetBuffer(), 0)
: (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
stream.Seek(4, SeekOrigin.Begin);
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("received message message type {0}", messageType);
}
if (_serializer == null)
{
throw new Exception("serializer not set");
}
object rc = _serializer.Deserialize(stream, messageType);
if (MessageReceived != null)
{
ProcessMsg(new RecvMessage()
{
Channel = this,
msg = rc,
Type = messageType
});
}
else
{
_logger.WarnFormat("drop message because not event handler, type {0}", messageType);
}
}
public void SavePredictionCompoments(int historyId)
{
EntityMap localEntites = _handler.LocalEntityMap;
#pragma warning disable RefCounter001,RefCounter002
EntityMap remoteEntities = PredictionEntityMap.Allocate();
#pragma warning restore RefCounter001,RefCounter002
EntityMapDeepCloner.Clone(remoteEntities, localEntites, _filter);
SavedHistory history = GetTargetHistory(historyId);
if (history == null)
{
_logger.DebugFormat("SavePredictionCompoments_1 {0}", historyId);
history = new SavedHistory(historyId, remoteEntities);
_histories.Add(history);
}
else
{
_logger.DebugFormat("Recplce SavePredictionCompoments {0}", historyId);
RefCounterRecycler.Instance.ReleaseReference(history.EntityMap);
history.EntityMap = remoteEntities;
}
if (_histories.Count > MaxHistory)
{
var tdhistory = _histories[0];
RefCounterRecycler.Instance.ReleaseReference(tdhistory.EntityMap);
_histories.RemoveAt(0);
}
}
protected bool IsUseActionEnabled()
{
var player = _playerContext.flagSelfEntity;
var states = player.StateInteractController().GetCurrStates();
var manager = SingletonManager.Get <StateTransitionConfigManager>();
foreach (var state in states)
{
StateTransitionConfigItem condition = manager.GetConditionByState(state);
if (condition == null)
{
continue;
}
if (!condition.GetTransition(Transition.IsUseAction) /*IsUseAction*/)
{
if (Logger.IsDebugEnabled)
{
Logger.DebugFormat("use action is limited by {0}", condition.State);
}
return(false);
}
else
{
if (Logger.IsDebugEnabled)
{
Logger.DebugFormat("use action is allowed by {0}", condition.State);
}
}
}
return(true);
}
/// <summary>
/// 直接修改NetworkAnimator的动画数据
/// </summary>
private void OverridePlayBackNetworkAnimator(PlayerEntity player,
List <NetworkAnimatorLayer> networkAnimatorAnimatorLayers)
{
var currentTime = _context.session.currentTimeObject.CurrentTime;
//覆盖受伤动画
if (player.hasOverrideNetworkAnimator && player.overrideNetworkAnimator.IsInjuryAnimatorActive)
{
var normalizeTime = (currentTime - player.overrideNetworkAnimator.InjuryTriigerTime) * 0.001f /
AnimatorParametersHash.InjureyStateDuration;
_logger.DebugFormat("player:{0}, normalizeTime:{1}, trigger time:{2} ,current time:{3}",
player.entityKey.Value, normalizeTime, player.overrideNetworkAnimator.InjuryTriigerTime,
_context.session.currentTimeObject.CurrentTime);
if (normalizeTime < 0)
{
_logger.DebugFormat("trigger time:{0} is lager than currentTime:{1}",
player.overrideNetworkAnimator.InjuryTriigerTime, currentTime);
}
else if (normalizeTime < 1 && normalizeTime >= 0)
{
NetworkAnimatorUtil.ForceToInjureState(networkAnimatorAnimatorLayers, normalizeTime);
}
else
{
player.overrideNetworkAnimator.IsInjuryAnimatorActive = false;
player.overrideNetworkAnimator.InjuryTriigerTime = -1;
}
}
}
public void OnHitVehicle(
PlayerEntity srcPlayer,
VehicleEntity targetVehicle,
IBulletEntity bulletEntity,
RaycastHit hit)
{
Collider collider = hit.collider;
VehiclePartIndex partIndex;
var hitBoxFactor = VehicleEntityUtility.GetHitFactor(targetVehicle, collider, out partIndex);
var totalDamage = GetBulletDamage(bulletEntity, hitBoxFactor);
var gameData = targetVehicle.GetGameData();
gameData.DecreaseHp(partIndex, totalDamage, srcPlayer.entityKey.Value);
srcPlayer.statisticsData.Statistics.TotalDamage += totalDamage;
bulletEntity.IsValid = false;
srcPlayer.statisticsData.Statistics.ShootingSuccCount++;
_logger.DebugFormat(
"bullet from {0} hit vehicle {1}, part {2}",
bulletEntity.OwnerEntityKey,
targetVehicle.entityKey.Value,
collider.name);
ClientEffectFactory.AddHitVehicleEffectEvent(
srcPlayer,
targetVehicle.entityKey.Value,
hit.point,
hit.point - targetVehicle.position.Value,
hit.normal);
}
public virtual void PlayerDead()
{
ControlRagDoll(true);
UnmountWeaponFromHand();
SetThridPerson();
Logger.DebugFormat("Player Dead");
}
public override void DoEventClient(IContexts contexts, IEntity entity, IEvent e)
{
var playerEntity = entity as PlayerEntity;
Contexts c = contexts as Contexts;
BeenHitEvent ev = e as BeenHitEvent;
var playerEntityTarget = c.player.GetEntityWithEntityKey(ev.Target);
if (playerEntity != null)
{
//服务器下发的被击中者调用受击命令
if (playerEntity.entityKey.Value == ev.Target && playerEntity.hasStateInterface)
{
Logger.DebugFormat("self:{0}, invoke , CanBeenHit:{1}", ev.Target, playerEntity.stateInterface.State.CanBeenHit());
if (playerEntity.stateInterface.State.CanBeenHit())
{
playerEntity.stateInterface.State.BeenHit();
}
}
//自己预测击中的受击者命令,强制使受击者播放受击动画
else
{
if (playerEntityTarget != null && playerEntityTarget.hasOverrideNetworkAnimator)
{
Logger.DebugFormat("target:{0}, invoke , IsInjuryAnimatorActive", ev.Target, ev.TriggerTime);
playerEntityTarget.overrideNetworkAnimator.IsInjuryAnimatorActive = true;
playerEntityTarget.overrideNetworkAnimator.InjuryTriigerTime = ev.TriggerTime;
}
}
}
}
public void MountWeaponToHand(WeaponInPackage pos)
{
var cmd = GetAvailableCommand();
cmd.SetChangeWeaponInHand(MountWeaponToHandImpl, pos);
Logger.DebugFormat("MountWeaponToHand: {0}", pos);
}
public override void OnAction()
{
_userCmdGenerator.SetUserCmd((cmd) => cmd.IsUseAction = true);
_userCmdGenerator.SetUserCmd((cmd) => cmd.UseVehicleSeat = _seatId);
_userCmdGenerator.SetUserCmd((cmd) => cmd.UseEntityId = _vehicleId);
_userCmdGenerator.SetUserCmd((cmd) => cmd.UseType = (int)EUseActionType.Vehicle);
Logger.DebugFormat("Action vehicle {0} seat {1}", _vehicleId, _seatId);
}
protected void SetNewCommandFromFunctionCall(FsmInput type, float additionalValue = 0)
{
Logger.DebugFormat("Request Do Action : {0} AdditionalValue : {1}", type, additionalValue);
var availableCommand = commandsContainer.GetAvailableItem();
availableCommand.Type = type;
availableCommand.AdditionalValue = additionalValue;
}
/// <summary>
/// 生成新加Component的Patch
/// </summary>
/// <param name="rightEntity"></param>
/// <param name="leftEntity"></param>
/// <param name="rightComponent"></param>
public override void OnLeftComponentMissing(IGameEntity leftEntity, IGameEntity rightEntity, IGameComponent rightComponent)
{
logger.DebugFormat("AddComponentPatch :{0}, {1}", leftEntity.EntityKey, rightComponent.GetComponentId());
var componentPatch = AddComponentPatch.Allocate(rightComponent);
currentEntityPatch.AddComponentPatch(componentPatch);
componentPatch.ReleaseReference();
}
public void SendSnapshot(int interval, SnapshotFactory snapshotFactory,
Dictionary <INetworkChannel, PlayerEntity> channelToPlayer)
{
var sessionObjects = _contexts.session.serverSessionObjects;
Bin2DConfig bin2DConfig = sessionObjects.Bin2DConfig;
IBin2DManager bin = sessionObjects.Bin2dManager;
int snapshotSeq = sessionObjects.GetNextSnapshotSeq();
int vehicleSimulationTime = sessionObjects.SimulationTimer.CurrentTime;
int serverTime = _contexts.session.currentTimeObject.CurrentTime;
_sendSnapshotTasks.Clear();
var freeMoveEntitys = _globalFreeMoveEntities.GetEntities();
var weaponEntities = _globalWeaponEntities.GetEntities();
foreach (var entry in channelToPlayer)
{
INetworkChannel channel = entry.Key;
PlayerEntity player = entry.Value;
if (player.hasStage &&
player.stage.CanSendSnapshot() &&
channel.IsConnected &&
!player.network.NetworkChannel.Serializer.MessageTypeInfo.SkipSendSnapShot(serverTime))
{
var p = ObjectAllocatorHolder <CreateSnapshotParams> .Allocate().Build(snapshotFactory, player,
bin2DConfig, bin, serverTime,
snapshotSeq,
vehicleSimulationTime, channel);
var entitys = p.PreEnitys;
AddTeamPlayers(player, entitys, _contexts);
AddGlobalFreeMove(player, entitys, freeMoveEntitys);
AddWeapon(player, entitys, weaponEntities);
_sendSnapshotTasks.Add(p);
}
else
{
player.network.NetworkChannel.Serializer.MessageTypeInfo.IncSendSnapShot();
_logger.DebugFormat("channel:{2} skip SendSnapshot :{0} {1}!", channel.IsConnected,
!player.network.NetworkChannel.Serializer.MessageTypeInfo.SkipSendSnapShot(serverTime),
channel.IdInfo());
}
}
if (SharedConfig.MutilThread)
{
#if ENABLE_NEW_SENDSNAPSHOT_THREAD
ConsumerExecute();
#else
MutilExecute();
#endif
}
else
{
MainExecute();
}
_logger.DebugFormat("SendSnapshot Threads Done;");
}
public virtual void Interpolate(object left, object right, IInterpolationInfo interpolationInfo)
{
AbstractNetworkAnimator leftComponent = (AbstractNetworkAnimator)left;
AbstractNetworkAnimator rightComponent = (AbstractNetworkAnimator)right;
InitFields(leftComponent);
BaseServerTime = leftComponent.BaseServerTime;
BaseClientTime = leftComponent.BaseClientTime;
NeedChangeServerTime = leftComponent.NeedChangeServerTime;
if (AnimatorLayers.Count > 0 && _networkAnimatorLogger.IsDebugEnabled)
{
_networkAnimatorLogger.DebugFormat("EntityName:{0}, before Interpolate, layer 0:{1}", _entityName,
AnimatorLayers[0].ToString());
}
if (leftComponent.AnimatorLayers.Count > 0 && _networkAnimatorLogger.IsDebugEnabled)
{
_networkAnimatorLogger.DebugFormat("EntityName:{2},Interpolate\n left layer 0:{0}\nright layer 0:{1}",
leftComponent.AnimatorLayers[0], rightComponent.AnimatorLayers[0], _entityName);
}
AssignAnimatorLayers(leftComponent.AnimatorLayers,
rightComponent.AnimatorLayers,
leftComponent.BaseServerTime,
interpolationInfo.LeftServerTime,
interpolationInfo.CurrentRenderTime,
rightComponent.BaseServerTime,
interpolationInfo.RightServerTime,
interpolationInfo.Ratio);
AssignAnimatorParameters(leftComponent.AnimatorParameters);
if (AnimatorLayers.Count > 0 && _networkAnimatorLogger.IsDebugEnabled)
{
_networkAnimatorLogger.DebugFormat("EntityName:{1},after Interpolate, layer 0:{0}", AnimatorLayers[0], _entityName);
}
if (_networkAnimatorLogger.IsDebugEnabled)
{
_networkAnimatorLogger.DebugFormat(
"EntityName:{9},NetworkAnimatorComponent Interpolate, left.BaseServerTime:{0},right.BaseServerTime:{1}, baseServerTime delta:{2}\n interpolate.LeftServerTime:{3}, interpolate.RightServerTime:{4},interpolate.renderTime:{5},interpolate.Ratio:{6}\n interpolate deltaTime:{7}, render time delta:{8} ",
leftComponent.BaseServerTime,
rightComponent.BaseServerTime,
rightComponent.BaseServerTime - leftComponent.BaseServerTime,
interpolationInfo.LeftServerTime,
interpolationInfo.RightServerTime,
interpolationInfo.CurrentRenderTime,
interpolationInfo.Ratio,
interpolationInfo.RightServerTime - interpolationInfo.LeftServerTime,
interpolationInfo.CurrentRenderTime - _prevRenderTime,
_entityName
);
}
_prevRenderTime = interpolationInfo.CurrentRenderTime;
}
public override void AfterFireBullet(IPlayerWeaponState playerWeapon, IWeaponCmd cmd, int bullet)
{
KickbackGroup kickbackGroup = null;
var hOffsetFactor = 1f;
var vOffsetFactor = 1f;
if (playerWeapon.IsAiming)
{
kickbackGroup = _config.Aiming;
hOffsetFactor = _config.Aiming.HPunchOffsetFactor;
vOffsetFactor = _config.Aiming.VPunchOffsetFactor;
Logger.DebugFormat("animing offset {0}, {1}", hOffsetFactor, vOffsetFactor);
}
else
{
kickbackGroup = _config.Default;
hOffsetFactor = _config.Default.HPunchOffsetFactor;
vOffsetFactor = _config.Default.VPunchOffsetFactor;
Logger.DebugFormat("default offset {0}, {1}", hOffsetFactor, vOffsetFactor);
}
WeaponConfigNs.Kickback kickBackParams;
if (playerWeapon.IsAir)
{
kickBackParams = kickbackGroup.Air;
}
else if (playerWeapon.HorizontalVeocity > _config.FastMoveSpeed)
{
kickBackParams = kickbackGroup.FastMove;
}
else if (playerWeapon.IsProne)
{
kickBackParams = kickbackGroup.Prone;
}
else if (playerWeapon.IsDuckOrProneState)
{
kickBackParams = kickbackGroup.Duck;
}
else
{
kickBackParams = kickbackGroup.Base;
}
BaseKickBack(playerWeapon, cmd.CmdSeq + bullet,
kickBackParams.UpBase,
kickBackParams.LateralBase,
kickBackParams.UpModifier,
kickBackParams.LateralModifier,
kickBackParams.UpMax,
kickBackParams.LateralMax,
kickBackParams.LateralTurnback,
hOffsetFactor,
vOffsetFactor);
}
public void StartInternal()
{
lock (this)
{
_logger.DebugFormat("Execute :{0} StartInternal, queueCount {1}", Name, _queue.Count);
_isStart = true;
_queue.Clear();
}
}
public void OnMapObjLoaded(UnityObject unityObj)
{
FillTempGameObjectList(unityObj);
AddTempGameObjectToPool();
ClearTempGameObjectList();
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Load Scene Trigger Object Type {0} name{1}", _typeValue, unityObj.AsGameObject.name);
}
}
public void Dispose()
{
OnDispose();
SingletonManager.UnregisterSingleton <T>();
_logger.DebugFormat("DisposableSingleton {0} is disposed.", typeof(T));
//creat a new singleton on dispose.
Instance = new T();
SingletonManager.RegisterSingleton <T>();
_logger.DebugFormat("DisposableSingleton {0} is initialized.", typeof(T));
}
public void OnExpend(Entity playerEntity, EWeaponSlotType slot)
{
if (!slot.IsSlotChangeByCost())
{
return;
}
var player = playerEntity as PlayerEntity;
Logger.DebugFormat("{0} OnExpend", player.entityKey.Value);
LockPlayerBag(player);
}
public int Serialize(Stream outStream, object message)
{
var msg = message as UpdateLatestPacakge;
var binaryWriter = MyBinaryWriter.Allocate(outStream);
binaryWriter.Write(_version);
if (MessagePool.GetPackageBySeq(msg.Head.LastUserCmdSeq) != null)
{
_logger.ErrorFormat("repetition msg.Head.UserCmdSeq{0}", msg.Head.LastUserCmdSeq);
binaryWriter.Write((byte)0);
return(binaryWriter.WriterLenght);
}
MessagePool.AddMessage(msg);
MessagePool.ClearOldMessage(msg.Head.LastAckUserCmdSeq);
if (_sendHistoryStreams.Count > _sendCount)
{
RemoveHistoryFirst();
}
for (int i = 0; i < _sendCount; i++)
{
if (_sendHistorySeqs.Count > 0 && msg.Head.LastAckUserCmdSeq > 0 &&
_sendHistorySeqs.First() <= msg.Head.LastAckUserCmdSeq)
{
RemoveHistoryFirst();
}
else
{
break;
}
}
var stream = SerializeSinaglePackage(msg);
_sendHistoryStreams.AddLast(stream);
_sendHistorySeqs.AddLast(msg.Head.LastUserCmdSeq);
binaryWriter.Write((byte)_sendHistoryStreams.Count);
foreach (var sendHistroyStream in _sendHistoryStreams)
{
binaryWriter.Write(sendHistroyStream.Stream.GetBuffer(),
(int)(sendHistroyStream.Stream.Position - sendHistroyStream.Length), (int)sendHistroyStream.Length);
}
_logger.DebugFormat("send package{0}", binaryWriter.Position);
var ret = binaryWriter.WriterLenght;
binaryWriter.ReleaseReference();
return(ret);
}
/// <summary>
/// 计算当前速度
/// </summary>
/// <param name="player"></param>
private void CalcCurrentSpeed(PlayerEntity player)
{
var currentBuff = CalcuBuff(player);
var offsetSlope = Vector3.zero;
// 需要在斜面下滑
if (IsSlideAloneSlope(player.characterContoller.Value, SlideSlopeOffsetLow))
{
offsetSlope = HandleSlideAloneSlope(CalcOnPlayerSpeed(SlideDirection, player.characterContoller.Value.transform.forward));
KeepSlide = true;
// 只有在速度大于SlideSlopeMinSpeed时才播放下滑动画
if (Mathf.Abs(CurrentVelocity.y) > SlideSlopeMinSpeed)
{
player.stateInterface.State.SetSlide(true);
Logger.DebugFormat("set ani to slide, curvelocity:{0},IsSlideAloneSlope:{1}", CurrentVelocity.ToStringExt(), IsSlideAloneSlope(player.characterContoller.Value, SlideSlopeOffsetUp));
}
Logger.DebugFormat("set to move slide, slide alone slope, vec:{0}, Angle:{1}, slopeVec:{2}", CurrentVelocity.ToStringExt(), Vector3.Angle(Vector3.up, GroundInfo.groundNormal), SlideDirection.ToVector4());
}
else if (IsSlideFreefall(player))
{
KeepSlide = true;
player.stateInterface.State.SetSlide(true);
CalcuSpeedIfNotSlide(player, DeltaTime, currentBuff, LastVelocity);
Logger.DebugFormat("freefall slide, curvelocity:{0}", CurrentVelocity.ToStringExt());
}
else
{
KeepSlide = false;
player.stateInterface.State.SetSlide(false);
CalcuSpeedIfNotSlide(player, DeltaTime, currentBuff, LastVelocity);
if (IsHeadingOnPlain(player)) //贴合地面
{
CurrentVelocity.y = SlideDirectionTan * CurrentVelocity.magnitude - 0.1f;
}
}
// 计算最终的速度偏移
CurrentVelocityOffset = player.orientation.RotationYaw * CurrentVelocityOffsetRaw + offsetSlope;
if (IsJumpHitScene(player))
{
CurrentVelocity = JumpSpeedProject(player.characterContoller.Value.transform, player.characterContoller.Value.GetCharacterControllerHitInfo(HitType.Forward).HitNormal, CurrentVelocity);
Logger.DebugFormat("project speed, curvelocity:{0}", CurrentVelocity.ToStringExt());
}
// debug
if (IsVector3Evil(CurrentVelocity))
{
Logger.ErrorFormat("final CurrentVelocity calc is illegle, slopeDir:{0}, prevSpeed:{1}, LastNormal:{2}, set slopeDir to zero!!!, GroundInfo:{3}", CurrentVelocity.ToStringExt(), LastVelocity.ToStringExt(), LastNormal.ToStringExt(),
GroundInfo.ToString());
CurrentVelocity = Vector3.zero;
}
}
public override void OnExpend(IPlayerWeaponProcessor controller, EWeaponSlotType slot)
{
base.OnExpend(controller, slot);
if (!slot.IsSlotChangeByCost())
{
return;
}
if (Logger.IsDebugEnabled)
{
Logger.DebugFormat("{0} OnExpend", controller.Owner);
}
controller.BagLockState = true;
}
