protected virtual void AttackLanded(EvtAttackLanded evt)
{
if (!evt.attackResult.isFromBullet)
{
this.monster.FrameHalt(evt.attackResult.frameHalt);
}
}
private bool OnAttackLanded(EvtAttackLanded evt)
{
if (evt.attackResult.hitLevel == AttackResult.ActorHitLevel.Critical)
{
base.actor.abilityPlugin.HandleActionTargetDispatch(this.config.OnCriticalAttackActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.attackeeID), evt);
}
return(true);
}
private bool OnAttackLanded(EvtAttackLanded evt)
{
BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.attackeeID);
if (actor == null)
{
return(false);
}
AttackPattern.ActAttackEffects(this.config.AttackEffect, actor.entity, evt.attackResult.hitCollision.hitPoint, evt.attackResult.hitCollision.hitDir);
return(true);
}
private bool ListenAttackLanded(EvtAttackLanded evt)
{
ushort num = Singleton <RuntimeIDManager> .Instance.ParseCategory(evt.targetID);
ushort num2 = Singleton <RuntimeIDManager> .Instance.ParseCategory(evt.attackeeID);
if (((num == 3) || (num == 4)) && ((num2 == 3) || (num2 == 4)))
{
object[] args = new object[] { Miscs.GetDebugActorName(Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.targetID)), Miscs.GetDebugActorName(Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.attackeeID)), (evt.animEventID != null) ? evt.animEventID : "<!null>", evt.attackResult.GetDebugOutput() };
this.DebugLog("{0} 外在攻击到 {1} 成功, 判定 ID {2}, 攻击结果 {3}", args);
}
return(true);
}
public static EvtAttackLanded Deserialize(Packet_Event_EvtAttackLanded table, EvtAttackLanded obj)
{
if (obj == null)
{
obj = new EvtAttackLanded();
}
obj.targetID = table.TargetID;
obj.attackeeID = table.AttackeeID;
obj.animEventID = table.AnimEventID;
if (table.GetAttackResult(GetCachedTable <MPAttackResult>()) != null)
{
obj.attackResult = Deserialize(GetCachedTable <MPAttackResult>(), new AttackResult());
}
return(obj);
}
private bool OnAttackLandedOther(EvtAttackLanded evt)
{
MonoAnimatedHitboxDetect hitbox = null;
bool flag = false;
foreach (Tuple <MonoAnimatedHitboxDetect, HashSet <uint> > tuple in this._touchedEnemyList)
{
if ((tuple.Item1 != null) && tuple.Item2.Contains(evt.attackeeID))
{
hitbox = tuple.Item1;
flag = true;
break;
}
}
if (!flag)
{
return(false);
}
if (evt.attackResult.hitEffect <= AttackResult.AnimatorHitEffect.Light)
{
return(false);
}
BaseAbilityActor item = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.attackeeID);
if (item == null)
{
return(false);
}
HashSet <BaseAbilityActor> set = null;
foreach (Tuple <MonoAnimatedHitboxDetect, HashSet <BaseAbilityActor> > tuple2 in this._draggedEnemyList)
{
if (tuple2.Item1 == hitbox)
{
set = tuple2.Item2;
if (tuple2.Item2.Contains(item))
{
return(false);
}
}
}
if (set != null)
{
set.Add(item);
this.SetAdditiveVelocity(item, hitbox);
}
return(true);
}
private bool ListenAttackLanded(EvtAttackLanded evt)
{
KeyValuePair <int, string> item = new KeyValuePair <int, string>(this._frameIndex, evt.animEventID);
if ((!this._countAnimEventComboOnceInOneFrame || !this._frameHitSet.Contains(item)) && (((evt.attackResult.isAnimEventAttack && evt.attackResult.isInComboCount) && (!evt.attackResult.rejected && (Singleton <RuntimeIDManager> .Instance.ParseCategory(evt.targetID) == 3))) && Singleton <AvatarManager> .Instance.IsLocalAvatar(evt.targetID)))
{
this._frameHitSet.Add(item);
this.ResetComboTimer();
DelegateUtils.UpdateField(ref this.levelCombo, ((int)this.levelCombo) + 1, this.onLevelComboChanged);
if (Singleton <LevelScoreManager> .Instance.maxComboNum < this.levelCombo)
{
Singleton <LevelScoreManager> .Instance.maxComboNum = this.levelCombo;
}
}
return(true);
}
public void OnAttackLandedEvt(EvtAttackLanded evt)
{
if ((Singleton <RuntimeIDManager> .Instance.ParseCategory(evt.targetID) == 3) && (Singleton <RuntimeIDManager> .Instance.ParseCategory(evt.attackeeID) == 4))
{
AvatarActor attackerActor = Singleton <EventManager> .Instance.GetActor <AvatarActor>(evt.targetID);
if (((attackerActor != null) && (attackerActor.runtimeID != Singleton <AvatarManager> .Instance.GetLocalAvatar().GetRuntimeID())) && !(attackerActor is AvatarMirrorActor))
{
BaseMonoAvatar entity = attackerActor.entity as BaseMonoAvatar;
if (entity.IsAnimatorInTag(AvatarData.AvatarTagGroup.AttackTargetLeadDirection))
{
MonsterActor actor = Singleton <EventManager> .Instance.GetActor <MonsterActor>(evt.attackeeID);
if ((this.localAvatarLockedMonsterActor == null) || (this.localAvatarLockedMonsterActor.runtimeID != actor.runtimeID))
{
if (this.IsMonsterBoss(actor))
{
this.SetAllSubHPBarDisable();
}
else
{
MonoSubMonsterHPBar component;
if (this._subMonsterHPBarMap.ContainsKey(actor.runtimeID))
{
component = this._subMonsterHPBarMap[actor.runtimeID];
}
else
{
GameObject availableSubMonsterHPBar = this.GetAvailableSubMonsterHPBar();
availableSubMonsterHPBar.transform.SetParent(base.transform, false);
component = availableSubMonsterHPBar.GetComponent <MonoSubMonsterHPBar>();
}
if (this._avatarHPBarMap.ContainsKey(attackerActor.runtimeID) && (this._avatarHPBarMap[attackerActor.runtimeID] != component))
{
this._avatarHPBarMap[attackerActor.runtimeID].RemoveAttacker(attackerActor);
}
component.SetupView(attackerActor, actor, 0.1f, new Action <MonoSubMonsterHPBar>(this.OnHideHPBar));
this._avatarHPBarMap[attackerActor.runtimeID] = component;
this._subMonsterHPBarMap[actor.runtimeID] = component;
}
}
}
}
}
}
private bool OnAttackLanded(EvtAttackLanded evt)
{
bool flag = true;
BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.attackeeID);
if (((actor != null) && (actor is MonsterActor)) && !Singleton <AvatarManager> .Instance.IsLocalAvatar(base.actor.runtimeID))
{
if (Singleton <EventManager> .Instance.GetActor <AvatarActor>(Singleton <AvatarManager> .Instance.GetLocalAvatar().GetRuntimeID()).MuteOtherQTE)
{
return(false);
}
MonsterActor qteTarget = actor as MonsterActor;
foreach (QTECondition condition in this.config.TriggerConditions)
{
if (condition.QTEType == QTEConditionType.QTEAnimationTag)
{
flag &= this.QTERangeCheck(qteTarget, condition.QTERange);
bool flag2 = false;
for (int i = 0; i < condition.QTEValues.Length; i++)
{
flag2 |= evt.attackResult.hitEffect == ((int)Enum.Parse(typeof(AttackResult.AnimatorHitEffect), condition.QTEValues[i]));
}
flag &= flag2;
}
else if (condition.QTEType == QTEConditionType.QTEBuffTag)
{
flag = false;
break;
}
}
if ((flag && !this._avatarActor.IsSwitchInCD()) && !this._avatarActor.AllowOtherSwitchIn)
{
this.AddQTETarget(qteTarget);
this._avatarActor.EnableQTEAttack(this.config.QTEName);
this._qteMaxTimer.Reset(true);
}
}
return(false);
}
private bool QTEHitEffectCheck(EvtAttackLanded evt, AttackResult.AnimatorHitEffect targetHitEffect)
{
return((evt != null) && (evt.attackResult.hitEffect == targetHitEffect));
}
public virtual void AttackLanded(EvtAttackLanded evt)
{
this.avatar.FrameHalt(evt.attackResult.frameHalt);
}
private bool OnBeingHitResolve(EvtBeingHit evt)
{
evt.Resolve();
AttackResult attackResult = DamageModelLogic.ResolveAttackDataFinal(this, evt.attackData);
if (attackResult.hitCollision == null)
{
AttackResult.HitCollsion collsion = new AttackResult.HitCollsion {
hitPoint = this.prop.RootNode.position,
hitDir = -this.prop.transform.forward
};
attackResult.hitCollision = collsion;
}
if (!evt.attackData.isAnimEventAttack)
{
return(false);
}
if (base.isAlive != 0)
{
float totalDamage = attackResult.GetTotalDamage();
float newValue = base.HP - totalDamage;
if (newValue <= 0f)
{
newValue = 0f;
}
DelegateUtils.UpdateField(ref this.HP, newValue, newValue - base.HP, base.onHPChanged);
if (base.HP == 0f)
{
if (base.abilityState.ContainsState(AbilityState.Limbo))
{
this.BeingHit(attackResult, BeHitEffect.NormalBeHit, evt.sourceID);
}
else
{
this.BeingHit(attackResult, BeHitEffect.KillingBeHit, evt.sourceID);
this.Kill(evt.sourceID, evt.animEventID);
}
}
else
{
this.BeingHit(attackResult, BeHitEffect.NormalBeHit, evt.sourceID);
}
}
if ((attackResult.attackEffectPattern != null) && ((attackResult.hitEffectPattern == AttackResult.HitEffectPattern.Normal) || (attackResult.hitEffectPattern == AttackResult.HitEffectPattern.OnlyAttack)))
{
AttackPattern.ActAttackEffects(attackResult.attackEffectPattern, this.prop, attackResult.hitCollision.hitPoint, attackResult.hitCollision.hitDir);
}
if ((attackResult.beHitEffectPattern != null) && ((attackResult.hitEffectPattern == AttackResult.HitEffectPattern.Normal) || (attackResult.hitEffectPattern == AttackResult.HitEffectPattern.OnlyBeHit)))
{
AttackPattern.ActAttackEffects(attackResult.beHitEffectPattern, this.prop, attackResult.hitCollision.hitPoint, attackResult.hitCollision.hitDir);
}
if (evt.attackData.isAnimEventAttack)
{
EvtAttackLanded landed = new EvtAttackLanded(evt.sourceID, base.runtimeID, evt.animEventID, attackResult);
Singleton <EventManager> .Instance.FireEvent(landed, MPEventDispatchMode.Normal);
Singleton <NotifyManager> .Instance.FireNotify(new Notify(NotifyTypes.AttackLanded, landed));
}
else
{
Singleton <EventManager> .Instance.FireEvent(new EvtDamageLanded(evt.sourceID, base.runtimeID, attackResult), MPEventDispatchMode.Normal);
}
return(true);
}
protected virtual bool OnBeingHitResolve(EvtBeingHit evt)
{
evt.Resolve();
if (evt.attackData.rejected)
{
if (evt.attackData.rejectState == AttackResult.RejectType.RejectButShowAttackEffect)
{
this.AmendHitCollision(evt.attackData);
this.FireAttackDataEffects(evt.attackData);
}
return(false);
}
if ((base.isAlive == 0) || (evt.attackData.GetTotalDamage() > base.HP))
{
evt.attackData.attackeeAniDefenceRatio = 0f;
}
AttackResult attackResult = DamageModelLogic.ResolveAttackDataFinal(this, evt.attackData);
this.AmendHitCollision(attackResult);
if (base.isAlive != 0)
{
if (base.abilityState.ContainsState(AbilityState.Invincible))
{
attackResult.damage = 0f;
attackResult.plainDamage = 0f;
attackResult.fireDamage = 0f;
attackResult.thunderDamage = 0f;
attackResult.iceDamage = 0f;
attackResult.alienDamage = 0f;
attackResult.hitLevel = AttackResult.ActorHitLevel.Mute;
attackResult.hitEffect = AttackResult.AnimatorHitEffect.Mute;
attackResult.frameHalt += 5;
}
else if (base.abilityState.ContainsState(AbilityState.Endure))
{
attackResult.hitEffect = AttackResult.AnimatorHitEffect.Mute;
attackResult.frameHalt += 5;
}
if (!attackResult.isAnimEventAttack)
{
attackResult.hitEffect = AttackResult.AnimatorHitEffect.Mute;
attackResult.hitLevel = AttackResult.ActorHitLevel.Normal;
attackResult.hitEffectPattern = AttackResult.HitEffectPattern.OnlyBeHit;
attackResult.attackCameraShake = null;
attackResult.killEffect = KillEffect.KillNow;
}
float totalDamage = attackResult.GetTotalDamage();
float newValue = base.HP - totalDamage;
if (newValue <= 0f)
{
newValue = 0f;
}
if (base.abilityState.ContainsState(AbilityState.Undamagable))
{
DelegateUtils.UpdateField(ref this.HP, (float)base.HP, newValue - base.HP, base.onHPChanged);
}
else
{
DelegateUtils.UpdateField(ref this.HP, newValue, newValue - base.HP, base.onHPChanged);
evt.resolvedDamage = totalDamage;
}
if (base.HP == 0f)
{
if ((base.abilityState & AbilityState.Limbo) != AbilityState.None)
{
evt.beHitEffect = BeHitEffect.NormalBeHit;
this.BeingHit(attackResult, BeHitEffect.NormalBeHit);
}
else
{
if (attackResult.killEffect != KillEffect.KillTillHitAnimationEnd)
{
if ((this.monster.IsAnimatorInTag(MonsterData.MonsterTagGroup.Throw) || (evt.attackData.hitEffect == AttackResult.AnimatorHitEffect.ThrowUp)) || (evt.attackData.hitEffect == AttackResult.AnimatorHitEffect.ThrowUpBlow))
{
attackResult.killEffect = KillEffect.KillFastWithNormalAnim;
}
else if (((base.abilityState & AbilityState.WitchTimeSlowed) != AbilityState.None) || (attackResult.aniDamageRatio >= 0.9f))
{
attackResult.killEffect = KillEffect.KillFastWithDieAnim;
}
}
this.Kill(evt.sourceID, evt.animEventID, attackResult.killEffect);
evt.beHitEffect = BeHitEffect.KillingBeHit;
this.BeingHit(attackResult, BeHitEffect.KillingBeHit);
}
}
else
{
evt.beHitEffect = BeHitEffect.NormalBeHit;
this.BeingHit(attackResult, BeHitEffect.NormalBeHit);
}
}
else
{
evt.beHitEffect = BeHitEffect.OverkillBeHit;
this.BeingHit(attackResult, BeHitEffect.OverkillBeHit);
}
this.FireAttackDataEffects(attackResult);
if (evt.attackData.isAnimEventAttack)
{
EvtAttackLanded landed = new EvtAttackLanded(evt.sourceID, base.runtimeID, evt.animEventID, attackResult);
Singleton <EventManager> .Instance.FireEvent(landed, MPEventDispatchMode.Normal);
Singleton <NotifyManager> .Instance.FireNotify(new Notify(NotifyTypes.AttackLanded, landed));
}
else
{
Singleton <EventManager> .Instance.FireEvent(new EvtDamageLanded(evt.sourceID, base.runtimeID, attackResult), MPEventDispatchMode.Normal);
}
base.MarkImportantEventIsHandled(evt);
return(true);
}
private bool OnAttackLanded(EvtAttackLanded evt)
{
this.AttackLanded(evt);
base.MarkImportantEventIsHandled(evt);
return(true);
}
public static Offset <Packet_Event_EvtAttackLanded> Serialize(FlatBufferBuilder builder, EvtAttackLanded obj)
{
StringOffset animEventIDOffset = new StringOffset();
if (obj.animEventID != null)
{
animEventIDOffset = builder.CreateString(obj.animEventID);
}
Offset <MPAttackResult> attackResultOffset = new Offset <MPAttackResult>();
if (obj.attackResult != null)
{
attackResultOffset = Serialize(builder, obj.attackResult);
}
Packet_Event_EvtAttackLanded.StartPacket_Event_EvtAttackLanded(builder);
Packet_Event_EvtAttackLanded.AddTargetID(builder, obj.targetID);
Packet_Event_EvtAttackLanded.AddAttackeeID(builder, obj.attackeeID);
Packet_Event_EvtAttackLanded.AddAnimEventID(builder, animEventIDOffset);
Packet_Event_EvtAttackLanded.AddAttackResult(builder, attackResultOffset);
return(Packet_Event_EvtAttackLanded.EndPacket_Event_EvtAttackLanded(builder));
}
public static object DeserializeToObject(Table table, object obj)
{
if (table.GetType() == typeof(MoleMole.MPProtocol.MPStageData))
{
if (obj == null)
{
obj = new MoleMole.MPStageData();
}
return(Deserialize((MoleMole.MPProtocol.MPStageData)table, (MoleMole.MPStageData)obj));
}
if (table.GetType() == typeof(MoleMole.MPProtocol.MPAvatarDataItem))
{
if (obj == null)
{
obj = new MoleMole.MPAvatarDataItem();
}
return(Deserialize((MoleMole.MPProtocol.MPAvatarDataItem)table, (MoleMole.MPAvatarDataItem)obj));
}
if (table.GetType() == typeof(Packet_Event_EvtHittingOther))
{
if (obj == null)
{
obj = new EvtHittingOther();
}
return(Deserialize((Packet_Event_EvtHittingOther)table, (EvtHittingOther)obj));
}
if (table.GetType() == typeof(Packet_Event_EvtBeingHit))
{
if (obj == null)
{
obj = new EvtBeingHit();
}
return(Deserialize((Packet_Event_EvtBeingHit)table, (EvtBeingHit)obj));
}
if (table.GetType() == typeof(Packet_Event_EvtAttackLanded))
{
if (obj == null)
{
obj = new EvtAttackLanded();
}
return(Deserialize((Packet_Event_EvtAttackLanded)table, (EvtAttackLanded)obj));
}
if (table.GetType() == typeof(Packet_Event_EvtEvadeSuccess))
{
if (obj == null)
{
obj = new EvtEvadeSuccess();
}
return(Deserialize((Packet_Event_EvtEvadeSuccess)table, (EvtEvadeSuccess)obj));
}
if (table.GetType() == typeof(Packet_Event_EvtBulletHit))
{
if (obj == null)
{
obj = new EvtBulletHit();
}
return(Deserialize((Packet_Event_EvtBulletHit)table, (EvtBulletHit)obj));
}
if (table.GetType() == typeof(MPAttackData))
{
if (obj == null)
{
obj = new AttackData();
}
return(Deserialize((MPAttackData)table, (AttackData)obj));
}
if (table.GetType() == typeof(MPAttackResult))
{
if (obj == null)
{
obj = new AttackResult();
}
return(Deserialize((MPAttackResult)table, (AttackResult)obj));
}
if (table.GetType() != typeof(MPHitCollision))
{
return(obj);
}
if (obj == null)
{
obj = new AttackResult.HitCollsion();
}
return(Deserialize((MPHitCollision)table, (AttackResult.HitCollsion)obj));
}
