private void RedirecEventToAuthority(BaseEvent evt)
{
BaseMPIdentity identity = Singleton <MPManager> .Instance.TryGetIdentity(evt.targetID);
evt.remoteState = EventRemoteState.IsRedirected;
this.RedirectEvent((IEvtWithRemoteID)evt, identity.authorityPeerID);
}
private BaseMPIdentity CreateRemoteMPIdentity(System.Type type, uint runtimeID, MPRecvPacketContainer pc)
{
BaseMPIdentity identity = (BaseMPIdentity)Activator.CreateInstance(type);
identity.PreInitReplicateRemote(pc);
this.InitializeIdentity(identity, runtimeID);
return(identity);
}
private MPDispatchBehavior CheckForDispatchBehavior(BaseEvent evt)
{
System.Type item = evt.GetType();
if (!MPData.ReplicatedEventTypes.Contains(item))
{
return(MPDispatchBehavior.NormalDispatch);
}
if (evt.remoteState == EventRemoteState.IsAutorityReceiveRedirected)
{
return(MPDispatchBehavior.NormalDispatch);
}
if (evt.remoteState == EventRemoteState.IsRemoteReceiveHandledReplcated)
{
return(MPDispatchBehavior.NormalDispatch);
}
bool flag = false;
if (evt.remoteState == EventRemoteState.Idle)
{
flag = true;
}
else if (evt.remoteState == EventRemoteState.NeedCheckForRemote)
{
IEvtWithRemoteID eid = (IEvtWithRemoteID)evt;
uint senderID = eid.GetSenderID();
uint remoteID = eid.GetRemoteID();
BaseMPIdentity identity = this.ResolveRemoteModeIdentity(senderID);
BaseMPIdentity identity2 = this.ResolveRemoteModeIdentity(remoteID);
if ((identity2 == null) || (identity == null))
{
return(MPDispatchBehavior.RemoteModeDropped);
}
bool flag2 = identity.isAuthority || ((identity.remoteMode == IdentityRemoteMode.SendAndNoReceive) || (identity.remoteMode == IdentityRemoteMode.SendAndReceive));
bool flag3 = identity2.isAuthority || ((identity2.remoteMode == IdentityRemoteMode.ReceiveAndNoSend) || (identity2.remoteMode == IdentityRemoteMode.SendAndReceive));
flag = flag2 && flag3;
}
if (!Singleton <RuntimeIDManager> .Instance.IsSyncedRuntimeID(evt.targetID))
{
return(MPDispatchBehavior.NormalDispatch);
}
BaseMPIdentity identity3 = Singleton <MPManager> .Instance.TryGetIdentity(evt.targetID);
if (!flag || (identity3 == null))
{
return(MPDispatchBehavior.RemoteModeDropped);
}
if (identity3.isAuthority)
{
return(MPDispatchBehavior.NormalDispatch);
}
return(MPDispatchBehavior.RemoteModeDirectToAuthority);
}
private void InitializeIdentity(BaseMPIdentity identity, uint runtimeID)
{
identity.runtimeID = runtimeID;
identity.isOwner = identity.GetPeerID() == this._peer.peerID;
this._identities.Add(runtimeID, identity);
this._identitiesList.Add(identity);
identity.Init();
if (identity.isAuthority)
{
identity.OnAuthorityStart();
}
else
{
identity.OnRemoteStart();
}
}
private void RemoveMPIdentity(BaseMPIdentity identity)
{
this.ReleaseChannelSequenceForRuntimeID(identity.runtimeID);
identity.OnRemoval();
bool flag = this._identitiesList.Remove(identity) & this._identities.Remove(identity.runtimeID);
}
public void RegisterIdentity(uint runtimeID, int channelSequence, BaseMPIdentity identity)
{
this.BindImportantFixedChannel(runtimeID, channelSequence);
this.InitializeIdentity(identity, runtimeID);
}
public bool IsIdentityAuthority(uint runtimeID)
{
BaseMPIdentity identity = Singleton <MPManager> .Instance.TryGetIdentity(runtimeID);
return((identity != null) ? identity.isAuthority : false);
}
protected override bool ListenBulletHit(EvtBulletHit evt)
{
if (!base._bulletAttackDatas.ContainsKey(evt.targetID))
{
return(false);
}
BaseMPIdentity identity = Singleton <MPManager> .Instance.TryGetIdentity(evt.otherID);
if (((identity != null) && !identity.isAuthority) && !identity.remoteMode.IsRemoteReceive())
{
return(false);
}
AttackData attackData = base._bulletAttackDatas[evt.targetID];
attackData.isFromBullet = true;
bool flag = base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage;
bool flag2 = (base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage) || (base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDamageHitTarget);
bool flag3 = true;
bool flag4 = base.baseConfig.BulletHitType == BulletHitBehavior.NoDestroyAndRefresh;
BaseMonoEntity entity = Singleton <EventManager> .Instance.GetEntity(evt.otherID);
BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor(evt.otherID) as BaseAbilityActor;
if ((entity is MonoDummyDynamicObject) || ((identity != null) && !identity.remoteMode.IsRemoteReceive()))
{
flag2 = false;
flag = false;
flag3 = false;
flag4 = false;
}
else if (evt.hitEnvironment)
{
flag2 = true;
flag4 = false;
}
else if ((!evt.cannotBeReflected && (actor != null)) && actor.abilityState.ContainsState(AbilityState.ReflectBullet))
{
Singleton <EventManager> .Instance.FireEvent(new EvtAfterBulletReflected(evt.otherID, evt.targetID, base.actor.runtimeID, base._bulletAttackDatas[evt.targetID]), MPEventDispatchMode.Normal);
return(false);
}
AbilityTriggerBullet bulletActor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(evt.targetID);
if (flag2)
{
bulletActor.Kill();
base._bulletAttackDatas.Remove(evt.targetID);
}
else
{
attackData = attackData.Clone();
}
if (flag4)
{
bulletActor.triggerBullet.ResetInside(base.baseConfig.ResetTime);
}
base._evtsLs.Clear();
if (evt.hitEnvironment)
{
if (!evt.hitGround)
{
return(true);
}
EvtHittingOther item = new EvtHittingOther(base.actor.runtimeID, evt.otherID, attackData)
{
hitCollision = evt.hitCollision
};
base._evtsLs.Add(item);
}
else
{
attackData.hitCollision = evt.hitCollision;
base._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, evt.otherID, base.baseConfig.HitAnimEventID, attackData));
}
if (flag)
{
List <CollisionResult> list = CollisionDetectPattern.CylinderCollisionDetectBySphere(evt.hitCollision.hitPoint, evt.hitCollision.hitPoint, base.instancedAbility.Evaluate(base.baseConfig.HitExplodeRadius), 1f, Singleton <EventManager> .Instance.GetAbilityHitboxTargettingMask(base.actor.runtimeID, base.baseConfig.Targetting));
float y = evt.hitCollision.hitPoint.y;
for (int j = 0; j < list.Count; j++)
{
CollisionResult result = list[j];
BaseMonoEntity collisionResultEntity = AttackPattern.GetCollisionResultEntity(result.entity);
if ((collisionResultEntity != null) && (collisionResultEntity.GetRuntimeID() != evt.otherID))
{
result.hitPoint.y = y;
AttackData data2 = attackData.Clone();
AttackResult.HitCollsion collsion = new AttackResult.HitCollsion {
hitDir = result.hitForward,
hitPoint = result.hitPoint
};
data2.hitCollision = collsion;
base._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, collisionResultEntity.GetRuntimeID(), base.baseConfig.HitAnimEventID, data2));
}
}
}
if (flag3)
{
Vector3 hitPoint = evt.hitCollision.hitPoint;
if (base.baseConfig.ExplodeEffectGround)
{
hitPoint.y = 0f;
}
Vector3 hitDir = evt.hitCollision.hitDir;
hitDir.y = 0f;
base.FireTriggerBulletHitExplodeEffect(bulletActor, hitPoint, hitDir, false);
}
if (base.baseConfig.HitExplodeActions.Length > 0)
{
for (int k = 0; k < base._evtsLs.Count; k++)
{
base.actor.abilityPlugin.HandleActionTargetDispatch(base.baseConfig.HitExplodeActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(base._evtsLs[k].toID), evt);
}
}
for (int i = 0; i < base._evtsLs.Count; i++)
{
EvtHittingOther other2 = base._evtsLs[i];
AttackPattern.SendHitEvent(base.actor.runtimeID, other2.toID, other2.animEventID, other2.hitCollision, other2.attackData, false, MPEventDispatchMode.CheckRemoteMode);
}
return(true);
}
