public override T[] GetEnemyActorsOf <T>(BaseActor actor) where T : BaseActor
{
uint num = Singleton <RuntimeIDManager> .Instance.ParsePeerID(actor.runtimeID);
List <T> list = new List <T>();
for (int i = 1; i < this._peerGroups.Length; i++)
{
if (i != num)
{
List <uint> list2 = this._peerGroups[i];
for (int j = 0; j < list2.Count; j++)
{
for (int k = 0; k < list2.Count; k++)
{
T item = Singleton <EventManager> .Instance.GetActor <T>(list2[k]);
if (item != null)
{
list.Add(item);
}
}
}
}
}
return(list.ToArray());
}
private void RemoveActor(BaseActor actor)
{
this._actorIdsToCleanUp.Add(actor.runtimeID);
this._actorList.Remove(actor);
this._actors.Remove(actor.runtimeID);
ushort index = Singleton <RuntimeIDManager> .Instance.ParseCategory(actor.runtimeID);
this._categoryActors[index].Remove(actor);
Singleton <LevelManager> .Instance.gameMode.DestroyRuntimeID(actor.runtimeID);
}
protected string GetDebugName(uint runtimeID)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(runtimeID);
if (actor != null)
{
return(string.Format("<{0}({1:x})>", this.Truncate(actor.gameObject.name), actor.runtimeID));
}
return("<unknown!>");
}
protected override void ProcessInitedActor(BaseActor actor)
{
if (actor is MonsterActor)
{
((MonsterActor)actor).AddPlugin(new MPMonsterActorPlugin(actor));
}
else if (actor is AvatarActor)
{
((AvatarActor)actor).AddPlugin(new MPAvatarActorPlugin(actor));
}
}
private bool ListenKilled(EvtKilled evt)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.killerID);
if (((actor != null) && (actor is AvatarActor)) && Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID))
{
this._tempKilledNum++;
if (this._tempKilledNum >= this.targetKilledNum)
{
this.Finish();
}
}
return(false);
}
private bool ListenBeingHit(EvtBeingHit evt)
{
if (!evt.attackData.rejected)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.sourceID);
if (((actor == null) || !(actor is AvatarActor)) || !this._inStastics)
{
return(false);
}
int num = this._damageLs.SeekAddPosition <Tuple <float, float> >();
this._damageLs[num] = Tuple.Create <float, float>(this._stasticsTimer, evt.attackData.GetTotalDamage());
}
return(false);
}
private bool ListenSkillStart(EvtSkillStart evt)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
if (((actor == null) || !(actor is AvatarActor)) || (evt.skillID != ULTIMATE_SKILL_NAME))
{
return(false);
}
this._tempUltimateSkillAmount++;
if (this._tempUltimateSkillAmount >= this.targetUltimateSkillAmount)
{
this.Finish();
}
return(true);
}
public static string GetDebugActorName(BaseActor actor)
{
if (actor == null)
{
return("<!null>");
}
if (actor.IsActive())
{
return(string.Format("<{0}({1:x})>", Truncate(actor.gameObject.name, 10), actor.runtimeID));
}
if (actor.gameObject != null)
{
return(string.Format("<!inactive {0}({1:x})>", Truncate(actor.gameObject.name, 10), actor.runtimeID));
}
return(string.Format("<!dead:{0}>", actor.runtimeID));
}
private bool ListenBuffAdd(EvtBuffAdd evt)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
bool flag = (evt.abilityState & (AbilityState.Tied | AbilityState.TargetLocked | AbilityState.Fragile | AbilityState.Weak | AbilityState.AttackSpeedDown | AbilityState.MoveSpeedDown | AbilityState.Frozen | AbilityState.Poisoned | AbilityState.Burn | AbilityState.Paralyze | AbilityState.Stun | AbilityState.Bleed)) != AbilityState.None;
if (((actor != null) && (actor is AvatarActor)) && (Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID) && flag))
{
this._tempBeAddedDebuffNum++;
if (this._tempBeAddedDebuffNum > this.targetBeAddedDebuffNum)
{
this.Fail();
}
}
return(false);
}
private bool ListenBeingHit(EvtBeingHit evt)
{
if (!evt.attackData.rejected)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
if (((actor != null) && (actor is AvatarActor)) && (Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID) && evt.attackData.IsFinalResolved()))
{
this._tempDamageTaken += evt.attackData.GetTotalDamage();
if (this._tempDamageTaken > this.targetDamageTaken)
{
this.Fail();
}
}
}
return(false);
}
public override T[] GetAlliedActorsOf <T>(BaseActor actor) where T : BaseActor
{
uint index = Singleton <RuntimeIDManager> .Instance.ParsePeerID(actor.runtimeID);
List <T> list = new List <T>();
List <uint> list2 = this._peerGroups[index];
for (int i = 0; i < list2.Count; i++)
{
T item = Singleton <EventManager> .Instance.GetActor <T>(list2[i]);
if (item != null)
{
list.Add(item);
}
}
return(list.ToArray());
}
private bool ListenSkillStart(EvtSkillStart evt)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
if ((actor == null) || !(actor is AvatarActor))
{
return(false);
}
if ((evt.skillID == ULTIMATE_SKILL_NAME) && !this._tempTriggeredUltimateSkillAvatarIDs.Contains(evt.targetID))
{
this._tempTriggeredUltimateSkillAvatarIDs.Add(evt.targetID);
}
if (this._tempTriggeredUltimateSkillAvatarIDs.Count >= this.targetUltimateSkillAmountByDistinctAvatar)
{
this.Finish();
}
return(true);
}
private bool ListenBuffAdd(EvtBuffAdd evt)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
bool flag = (evt.abilityState & (AbilityState.Tied | AbilityState.TargetLocked | AbilityState.Fragile | AbilityState.Weak | AbilityState.AttackSpeedDown | AbilityState.MoveSpeedDown | AbilityState.Frozen | AbilityState.Poisoned | AbilityState.Burn | AbilityState.Paralyze | AbilityState.Stun | AbilityState.Bleed)) != AbilityState.None;
if (((actor != null) && (actor is MonsterActor)) && flag)
{
if (!this._addDebuffMonsterList.Contains(actor.runtimeID))
{
this._addDebuffMonsterList.Add(actor.runtimeID);
}
if (this._addDebuffMonsterList.Count >= this.targetDebuffAddNum)
{
this.Finish();
}
}
return(false);
}
public static string GetAnimIDAttackPropertyOutput(BaseActor actor, string animEventID)
{
if (actor != null)
{
if (actor is AvatarActor)
{
return(SharedAnimEventData.ResolveAnimEvent(((AvatarActor)actor).config, animEventID).AttackProperty.GetDebugOutput());
}
if (actor is MonsterActor)
{
return(SharedAnimEventData.ResolveAnimEvent(((MonsterActor)actor).config, animEventID).AttackProperty.GetDebugOutput());
}
if (actor is PropObjectActor)
{
return(SharedAnimEventData.ResolveAnimEvent(((PropObjectActor)actor).config, animEventID).AttackProperty.GetDebugOutput());
}
}
return(string.Format("<!null attack proeprty {0} on {1}>", GetDebugActorName(actor), animEventID));
}
private bool ListenBeingHit(EvtBeingHit evt)
{
if (evt.attackData.rejected)
{
return(false);
}
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.sourceID);
if (((actor == null) || !(actor is AvatarActor)) || (!this._inStastics || !Singleton <LevelManager> .Instance.levelActor.IsLevelBuffActive(LevelBuffType.WitchTime)))
{
return(false);
}
this._tempAllDamage += evt.attackData.damage;
if (this._tempAllDamage >= this.targetDamage)
{
this.Finish();
}
return(true);
}
private static float GetAnimDefenceRatio(BaseActor actor)
{
float animDefenceRatio = 0f;
if (actor is MonsterActor)
{
MonsterActor actor2 = (MonsterActor)actor;
float defaultAnimDefenceRatio = actor2.config.StateMachinePattern.DefaultAnimDefenceRatio;
string currentSkillID = actor2.monster.CurrentSkillID;
animDefenceRatio = defaultAnimDefenceRatio;
if (actor2.monster.IsAnimatorInTag(MonsterData.MonsterTagGroup.Throw))
{
return(actor2.config.StateMachinePattern.ThrowAnimDefenceRatio + actor2.GetProperty("Actor_ThrowAniDefenceDelta"));
}
if (string.IsNullOrEmpty(currentSkillID) || !actor2.config.Skills.ContainsKey(currentSkillID))
{
return(animDefenceRatio);
}
float num3 = actor2.monster.GetCurrentNormalizedTime() % 1f;
ConfigMonsterSkill skill = actor2.config.Skills[currentSkillID];
if ((num3 <= skill.AnimDefenceNormalizedTimeStart) || (num3 >= skill.AnimDefenceNormalizedTimeStop))
{
return(animDefenceRatio);
}
return(skill.AnimDefenceRatio);
}
if (actor is AvatarActor)
{
AvatarActor actor3 = (AvatarActor)actor;
animDefenceRatio = actor3.config.StateMachinePattern.DefaultAnimDefenceRatio;
string str2 = actor3.avatar.CurrentSkillID;
if (!string.IsNullOrEmpty(str2) && actor3.config.Skills.ContainsKey(str2))
{
float num4 = actor3.avatar.GetCurrentNormalizedTime() % 1f;
ConfigAvatarSkill skill2 = actor3.config.Skills[str2];
if ((num4 > skill2.AnimDefenceNormalizedTimeStart) && (num4 < skill2.AnimDefenceNormalizedTimeStop))
{
animDefenceRatio = skill2.AnimDefenceRatio;
}
}
}
return(animDefenceRatio);
}
private bool ListenBeingHit(EvtBeingHit evt)
{
if (!evt.attackData.rejected)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
if (((actor != null) && (actor is AvatarActor)) && Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID))
{
if (evt.attackData.hitEffect == AttackResult.AnimatorHitEffect.KnockDown)
{
this._beHitDownNum++;
}
if (this._beHitDownNum > this.targetDownNum)
{
this.Fail();
}
}
}
return(false);
}
private bool ListenFieldEnter(EvtFieldEnter evt)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
BaseActor actor2 = Singleton <EventManager> .Instance.GetActor(evt.otherID);
if ((((actor != null) && (actor is PropObjectActor)) && ((actor2 != null) && (actor2 is AvatarActor))) && Singleton <AvatarManager> .Instance.IsLocalAvatar(actor2.runtimeID))
{
PropObjectActor actor3 = actor as PropObjectActor;
if ((actor3 != null) && (actor3.entity is MonoTriggerProp))
{
this._trapTriggeredNum++;
if (this._trapTriggeredNum >= this.targetNum)
{
this.Fail();
}
}
}
return(false);
}
private bool ListenKilled(EvtKilled evt)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.killerID);
BaseActor actor2 = Singleton <EventManager> .Instance.GetActor(evt.targetID);
if ((((actor != null) && (actor is AvatarActor)) && (Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID) && (actor2 != null))) && (actor2 is PropObjectActor))
{
PropObjectActor actor3 = actor2 as PropObjectActor;
if ((actor3 != null) && actor3.config.Name.Contains("Box"))
{
this._tempBoxOpenedNum++;
if (this._tempBoxOpenedNum >= this.targetBoxOpenedNum)
{
this.Finish();
}
}
}
return(false);
}
private bool ListenBeingHit(EvtBeingHit evt)
{
if (!evt.attackData.rejected)
{
if (!evt.attackData.isAnimEventAttack)
{
return(false);
}
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
if (((actor != null) && (actor is AvatarActor)) && (Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID) && evt.attackData.isInComboCount))
{
this._beHitNum++;
if (this._beHitNum > this.targetNum)
{
this.Fail();
}
}
}
return(false);
}
private bool ListenSkillStart(EvtSkillStart evt)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
if (((actor is AvatarActor) && (actor as AvatarActor).config.Skills.ContainsKey(evt.skillID)) && ((actor as AvatarActor).config.Skills[evt.skillID].SkillCategoryTag != null))
{
for (int i = 0; i < (actor as AvatarActor).config.Skills[evt.skillID].SkillCategoryTag.Length; i++)
{
if ((actor as AvatarActor).config.Skills[evt.skillID].SkillCategoryTag[i] == AttackResult.AttackCategoryTag.Evade)
{
this._witchTimeTiggered++;
break;
}
}
}
if (this._witchTimeTiggered >= this.targetNum)
{
this.Finish();
}
return(false);
}
private bool ListenBeingHit(EvtBeingHit evt)
{
if (!evt.attackData.rejected)
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(evt.targetID);
BaseActor actor2 = Singleton <EventManager> .Instance.GetActor(evt.sourceID);
if ((((actor != null) && (actor is AvatarActor)) && (Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID) && (actor2 != null))) && (actor2 is PropObjectActor))
{
PropObjectActor actor3 = actor2 as PropObjectActor;
if ((actor3 != null) && (actor3.entity is MonoTriggerProp))
{
this._trapTriggeredNum++;
if (this._trapTriggeredNum >= this.targetNum)
{
this.Fail();
}
}
}
}
return(false);
}
public static AttackData CreateAttackDataFromAttackerAnimEvent(BaseActor from, string animEventID)
{
if (from is AvatarActor)
{
AvatarActor actor = (AvatarActor)from;
ConfigAvatarAnimEvent event2 = SharedAnimEventData.ResolveAnimEvent(actor.config, animEventID);
return(CreateAttackDataFromAttackProperty(from, event2.AttackProperty, event2.AttackEffect, event2.CameraShake));
}
if (from is MonsterActor)
{
MonsterActor actor2 = (MonsterActor)from;
ConfigMonsterAnimEvent event3 = SharedAnimEventData.ResolveAnimEvent(actor2.config, animEventID);
AttackData attackData = CreateAttackDataFromAttackProperty(from, event3.AttackProperty, event3.AttackEffect, event3.CameraShake);
actor2.RefillAttackDataDamagePercentage(animEventID, ref attackData);
return(attackData);
}
if (from is PropObjectActor)
{
PropObjectActor actor3 = (PropObjectActor)from;
ConfigPropAnimEvent event4 = SharedAnimEventData.ResolveAnimEvent(actor3.config, animEventID);
return(CreateAttackDataFromAttackProperty(from, event4.AttackProperty, event4.AttackEffect, event4.CameraShake));
}
return(null);
}
public override bool IsEnemy(uint fromID, uint toID)
{
if (!Singleton <RuntimeIDManager> .Instance.IsSyncedRuntimeID(fromID))
{
BaseActor actor = Singleton <EventManager> .Instance.GetActor(fromID);
if (actor == null)
{
return(false);
}
fromID = actor.ownerID;
}
if (!Singleton <RuntimeIDManager> .Instance.IsSyncedRuntimeID(toID))
{
BaseActor actor2 = Singleton <EventManager> .Instance.GetActor(toID);
if (actor2 == null)
{
return(false);
}
toID = actor2.ownerID;
}
return(Singleton <RuntimeIDManager> .Instance.ParsePeerID(fromID) != Singleton <RuntimeIDManager> .Instance.ParsePeerID(toID));
}
public MPMonsterActorPlugin(BaseActor actor)
{
this._actor = (MonsterActor)actor;
}
public static AttackData CreateAttackDataFromAttackProperty(BaseActor from, ConfigEntityAttackProperty attackProperty, ConfigEntityAttackEffect attackEffect, ConfigEntityCameraShake cameraShake)
{
AttackData data = new AttackData();
if (from is AvatarActor)
{
AvatarActor actor = (AvatarActor)from;
data.attackCategoryTag = attackProperty.CategoryTagCombined;
data.attackerClass = actor.config.CommonArguments.Class;
data.attackerNature = (EntityNature)actor.avatarDataItem.Attribute;
data.attackerCategory = 3;
data.attackerAniDamageRatio = attackProperty.AniDamageRatio;
data.frameHalt = attackProperty.FrameHalt;
data.hitType = attackProperty.HitType;
data.hitEffect = attackProperty.HitEffect;
data.hitEffectAux = attackProperty.HitEffectAux;
data.attackerLevel = (int)actor.level;
data.retreatVelocity = attackProperty.RetreatVelocity;
data.attackerCritChance = ((actor.critical + actor.GetProperty("Actor_CriticalDelta")) * (1f + actor.GetProperty("Actor_CriticalRatio"))) / ((float)(0x4b + (actor.level * 5)));
data.attackerCritDamageRatio = 2f;
data.attackerAttackValue = (float)actor.attack;
data.attackerAttackPercentage = attackProperty.DamagePercentage;
data.attackerAddedAttackValue = attackProperty.AddedDamageValue;
data.attackerNormalDamage = attackProperty.NormalDamage;
data.attackerNormalDamagePercentage = attackProperty.NormalDamagePercentage;
data.addedAttackerNormalDamageRatio = actor.GetProperty("Actor_NormalAttackRatio");
data.attackerFireDamage = attackProperty.FireDamage;
data.attackerFireDamagePercentage = attackProperty.FireDamagePercentage;
data.addedAttackerFireDamageRatio = actor.GetProperty("Actor_FireAttackRatio");
data.attackerThunderDamage = attackProperty.ThunderDamage;
data.attackerThunderDamagePercentage = attackProperty.ThunderDamagePercentage;
data.addedAttackerThunderDamageRatio = actor.GetProperty("Actor_ThunderAttackRatio");
data.attackerIceDamage = attackProperty.IceDamage;
data.attackerIceDamagePercentage = attackProperty.IceDamagePercentage;
data.addedAttackerIceDamageRatio = actor.GetProperty("Actor_IceAttackRatio");
data.attackerAlienDamage = attackProperty.AlienDamage;
data.attackerAlienDamagePercentage = attackProperty.AlienDamagePercentage;
data.addedAttackerAlienDamageRatio = actor.GetProperty("Actor_AllienAttackRatio");
data.killEffect = attackProperty.KillEffect;
data.hitEffectPattern = AttackResult.HitEffectPattern.Normal;
data.isInComboCount = attackProperty.IsInComboCount;
data.isAnimEventAttack = attackProperty.IsAnimEventAttack;
data.noBreakFrameHaltAdd = attackProperty.NoBreakFrameHaltAdd;
data.attackEffectPattern = attackEffect;
if (data.attackEffectPattern == null)
{
data.attackEffectPattern = (data.attackerAniDamageRatio < 0.8f) ? InLevelData.InLevelMiscData.DefaultAvatarAttackSmallEffect : InLevelData.InLevelMiscData.DefaultAvatarAttackBigEffect;
}
if (Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID))
{
data.attackCameraShake = cameraShake;
}
data.attackerAniDamageRatio += actor.GetProperty("Actor_AniDamageDelta");
data.attackerCritChance += actor.GetProperty("Actor_CriticalChanceDelta");
data.attackerCritDamageRatio += actor.GetProperty("Actor_CriticalDamageRatio");
data.attackerAttackValue = (data.attackerAttackValue + actor.GetProperty("Actor_AttackDelta")) * (1f + actor.GetProperty("Actor_AttackRatio"));
data.addedDamageRatio = actor.GetProperty("Actor_AddedDamageRatio");
data.addedAttackRatio = actor.GetProperty("Actor_AddedAttackRatio");
data.attackerShieldDamageRatio = 1f + actor.GetProperty("Actor_ShieldDamageRatio");
data.attackerShieldDamageDelta = actor.GetProperty("Actor_ShieldDamageDelta");
data.retreatVelocity *= 1f + actor.GetProperty("Actor_RetreatRatio");
}
else if (from is MonsterActor)
{
MonsterActor actor2 = (MonsterActor)from;
data.attackCategoryTag = attackProperty.CategoryTagCombined;
data.attackerClass = actor2.config.CommonArguments.Class;
data.attackerNature = (EntityNature)actor2.metaConfig.nature;
data.attackerCategory = 4;
data.attackerAniDamageRatio = attackProperty.AniDamageRatio;
data.frameHalt = attackProperty.FrameHalt;
data.hitType = attackProperty.HitType;
data.hitEffect = attackProperty.HitEffect;
data.hitEffectAux = attackProperty.HitEffectAux;
data.hitEffectPattern = AttackResult.HitEffectPattern.Normal;
data.retreatVelocity = attackProperty.RetreatVelocity;
data.attackerLevel = (int)actor2.level;
data.attackerAttackValue = (float)actor2.attack;
data.attackerAttackPercentage = attackProperty.DamagePercentage;
data.attackerAddedAttackValue = attackProperty.AddedDamageValue;
data.attackerNormalDamage = attackProperty.NormalDamage;
data.attackerNormalDamagePercentage = attackProperty.NormalDamagePercentage;
data.addedAttackerNormalDamageRatio = actor2.GetProperty("Actor_NormalAttackRatio");
data.attackerFireDamage = attackProperty.FireDamage;
data.attackerFireDamagePercentage = attackProperty.FireDamagePercentage;
data.addedAttackerFireDamageRatio = actor2.GetProperty("Actor_FireAttackRatio");
data.attackerThunderDamage = attackProperty.ThunderDamage;
data.attackerThunderDamagePercentage = attackProperty.ThunderDamagePercentage;
data.addedAttackerThunderDamageRatio = actor2.GetProperty("Actor_ThunderAttackRatio");
data.attackerIceDamage = attackProperty.IceDamage;
data.attackerIceDamagePercentage = attackProperty.IceDamagePercentage;
data.addedAttackerIceDamageRatio = actor2.GetProperty("Actor_IceAttackRatio");
data.attackerAlienDamage = attackProperty.AlienDamage;
data.attackerAlienDamagePercentage = attackProperty.AlienDamagePercentage;
data.addedAttackerAlienDamageRatio = actor2.GetProperty("Actor_AllienAttackRatio");
data.noTriggerEvadeAndDefend = attackProperty.NoTriggerEvadeAndDefend;
data.attackEffectPattern = attackEffect;
if (data.attackEffectPattern == null)
{
data.attackEffectPattern = InLevelData.InLevelMiscData.DefaultMonsterAttackEffect;
}
data.attackCameraShake = cameraShake;
data.isAnimEventAttack = attackProperty.IsAnimEventAttack;
data.attackerAniDamageRatio += actor2.GetProperty("Actor_AniDamageDelta");
data.attackerAttackValue = (data.attackerAttackValue + actor2.GetProperty("Actor_AttackDelta")) * (1f + actor2.GetProperty("Actor_AttackRatio"));
data.addedAttackRatio = actor2.GetProperty("Actor_AddedAttackRatio");
data.attackerShieldDamageRatio = 1f + actor2.GetProperty("Actor_ShieldDamageRatio");
data.attackerShieldDamageDelta = actor2.GetProperty("Actor_ShieldDamageDelta");
data.retreatVelocity *= 1f + actor2.GetProperty("Actor_RetreatRatio");
}
else if (from is BaseAbilityActor)
{
BaseAbilityActor actor3 = (BaseAbilityActor)from;
data.attackCategoryTag = attackProperty.CategoryTagCombined;
data.attackerClass = EntityClass.Default;
data.attackerNature = EntityNature.Pure;
data.attackerCategory = 7;
data.attackerAniDamageRatio = attackProperty.AniDamageRatio;
data.frameHalt = attackProperty.FrameHalt;
data.hitType = attackProperty.HitType;
data.hitEffect = attackProperty.HitEffect;
data.hitEffectAux = attackProperty.HitEffectAux;
data.retreatVelocity = attackProperty.RetreatVelocity;
data.attackerLevel = 0;
data.attackerAttackPercentage = attackProperty.DamagePercentage;
data.attackerAttackValue = (float)actor3.attack;
data.attackerAttackPercentage = attackProperty.DamagePercentage;
data.attackerAddedAttackValue = attackProperty.AddedDamageValue;
data.attackerNormalDamage = attackProperty.NormalDamage;
data.attackerNormalDamagePercentage = attackProperty.NormalDamagePercentage;
data.addedAttackerNormalDamageRatio = actor3.GetProperty("Actor_NormalAttackRatio");
data.attackerFireDamage = attackProperty.FireDamage;
data.attackerFireDamagePercentage = attackProperty.FireDamagePercentage;
data.addedAttackerFireDamageRatio = actor3.GetProperty("Actor_FireAttackRatio");
data.attackerThunderDamage = attackProperty.ThunderDamage;
data.attackerThunderDamagePercentage = attackProperty.ThunderDamagePercentage;
data.addedAttackerThunderDamageRatio = actor3.GetProperty("Actor_ThunderAttackRatio");
data.attackerIceDamage = attackProperty.IceDamage;
data.attackerIceDamagePercentage = attackProperty.IceDamagePercentage;
data.addedAttackerIceDamageRatio = actor3.GetProperty("Actor_IceAttackRatio");
data.attackerAlienDamage = attackProperty.AlienDamage;
data.attackerAlienDamagePercentage = attackProperty.AlienDamagePercentage;
data.addedAttackerAlienDamageRatio = actor3.GetProperty("Actor_AllienAttackRatio");
data.attackEffectPattern = attackEffect;
if (data.attackEffectPattern == null)
{
data.attackEffectPattern = InLevelData.InLevelMiscData.DefaultMonsterAttackEffect;
}
data.attackCameraShake = cameraShake;
data.isAnimEventAttack = attackProperty.IsAnimEventAttack;
data.attackerAniDamageRatio += actor3.GetProperty("Actor_AniDamageDelta");
data.attackerAttackValue = (data.attackerAttackValue + actor3.GetProperty("Actor_AttackDelta")) * (1f + actor3.GetProperty("Actor_AttackRatio"));
data.addedAttackRatio = actor3.GetProperty("Actor_AddedAttackRatio");
data.attackerShieldDamageRatio = 1f + actor3.GetProperty("Actor_ShieldDamageRatio");
data.attackerShieldDamageDelta = actor3.GetProperty("Actor_ShieldDamageDelta");
data.retreatVelocity *= 1f + actor3.GetProperty("Actor_RetreatRatio");
}
data.resolveStep = AttackData.AttackDataStep.AttackerResolved;
return(data);
}
public static AttackResult ResolveAttackDataFinal(BaseActor attackee, AttackData attackData)
{
if (!attackData.rejected)
{
if ((attackData.attackeeAniDefenceRatio > attackData.attackerAniDamageRatio) && (attackData.hitEffect > AttackResult.AnimatorHitEffect.Light))
{
attackData.hitEffect = AttackResult.AnimatorHitEffect.Light;
}
if ((attackee is MonsterActor) && (attackData.beHitEffectPattern == null))
{
MonsterActor actor = (MonsterActor)attackee;
if ((attackData.isAnimEventAttack && (attackData.hitEffect == AttackResult.AnimatorHitEffect.Light)) && (attackData.attackerAniDamageRatio > 0.4f))
{
if (((attackData.attackEffectPattern == null) || !attackData.attackEffectPattern.MuteAttackEffect) && (actor.IsActive() && (actor.monster.CurrentSkillID != null)))
{
ConfigMonsterSkill skill = actor.config.Skills[actor.monster.CurrentSkillID];
if (actor.monster.GetCurrentNormalizedTime() < skill.AttackNormalizedTimeStop)
{
attackData.beHitEffectPattern = InLevelData.InLevelMiscData.NoBreakBehitEffect;
}
}
}
else if (actor.abilityState.ContainsState(AbilityState.Frozen))
{
attackData.beHitEffectPattern = InLevelData.InLevelMiscData.FrozenBehitEffect;
}
else if (attackData.attackerAniDamageRatio <= 0.6f)
{
attackData.beHitEffectPattern = actor.config.StateMachinePattern.BeHitEffect;
}
else if (attackData.attackerAniDamageRatio <= 0.8f)
{
attackData.beHitEffectPattern = actor.config.StateMachinePattern.BeHitEffectMid;
}
else
{
attackData.beHitEffectPattern = actor.config.StateMachinePattern.BeHitEffectBig;
}
}
attackData.aniDamageRatio = attackData.attackerAniDamageRatio;
List <KeyValuePair <AttackResult.ElementType, float> > list = new List <KeyValuePair <AttackResult.ElementType, float> > {
new KeyValuePair <AttackResult.ElementType, float>(0, attackData.plainDamage),
new KeyValuePair <AttackResult.ElementType, float>(3, attackData.iceDamage),
new KeyValuePair <AttackResult.ElementType, float>(1, attackData.fireDamage),
new KeyValuePair <AttackResult.ElementType, float>(2, attackData.thunderDamage),
new KeyValuePair <AttackResult.ElementType, float>(4, attackData.alienDamage)
};
KeyValuePair <AttackResult.ElementType, float> pair = list[0];
for (int i = 1; i < list.Count; i++)
{
KeyValuePair <AttackResult.ElementType, float> pair2 = list[i];
if (pair2.Value > pair.Value)
{
pair = pair2;
}
}
attackData.plainDamage = 0f;
attackData.iceDamage = 0f;
attackData.fireDamage = 0f;
attackData.thunderDamage = 0f;
attackData.alienDamage = 0f;
switch (pair.Key)
{
case AttackResult.ElementType.Plain:
attackData.plainDamage = pair.Value;
break;
case AttackResult.ElementType.Fire:
attackData.fireDamage = pair.Value;
break;
case AttackResult.ElementType.Thunder:
attackData.thunderDamage = pair.Value;
break;
case AttackResult.ElementType.Ice:
attackData.iceDamage = pair.Value;
break;
case AttackResult.ElementType.Alien:
attackData.alienDamage = pair.Value;
break;
}
attackData.resolveStep = AttackData.AttackDataStep.FinalResolved;
}
return(attackData);
}
public static void ResolveAttackDataByAttackee(BaseActor to, AttackData attackData)
{
if (!attackData.rejected)
{
if (to is AvatarActor)
{
AvatarActor actor = (AvatarActor)to;
bool flag = Singleton <LevelScoreManager> .Instance.IsAllowLevelPunish();
int levelDifference = Mathf.Clamp(attackData.attackerLevel - Singleton <PlayerModule> .Instance.playerData.teamLevel, 0, 10);
if ((attackData.attackerCategory == 4) && flag)
{
attackData.attackerAniDamageRatio *= 1f + AvatarDefencePunishMetaDataReader.GetAvatarDefencePunishMetaDataByKey(levelDifference).AttackRatioIncrease;
}
attackData.attackeeAniDefenceRatio = GetAnimDefenceRatio(actor);
attackData.damage = (((attackData.attackerAttackValue * attackData.attackerAttackPercentage) + attackData.attackerAddedAttackValue) * (1f + attackData.addedAttackRatio)) * (1f + attackData.addedDamageRatio);
float defence = (actor.defense + actor.GetProperty("Actor_DefenceDelta")) * (1f + actor.GetProperty("Actor_DefenceRatio"));
float defenceRatio = GetDefenceRatio(defence, attackData.attackerLevel);
float num4 = (1f - defenceRatio) * actor.GetProperty("Actor_DamageReduceRatio");
attackData.attackeeAddedDamageTakeRatio += actor.GetProperty("Actor_DamageTakeRatio");
attackData.damage = (attackData.damage * num4) * (1f + attackData.attackeeAddedDamageTakeRatio);
attackData.plainDamage = (((((attackData.attackerNormalDamage + (attackData.attackerAttackValue * attackData.attackerNormalDamagePercentage)) * (1f + attackData.addedAttackerNormalDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor.GetProperty("Actor_ResistAllElementAttackRatio")) * actor.GetProperty("Actor_ResistNormalAttackRatio")) * (1f + actor.GetProperty("Actor_NormalAttackTakeRatio"));
attackData.fireDamage = (((((attackData.attackerFireDamage + (attackData.attackerAttackValue * attackData.attackerFireDamagePercentage)) * (1f + attackData.addedAttackerFireDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor.GetProperty("Actor_ResistAllElementAttackRatio")) * actor.GetProperty("Actor_ResistFireAttackRatio")) * (1f + actor.GetProperty("Actor_FireAttackTakeRatio"));
attackData.thunderDamage = (((((attackData.attackerThunderDamage + (attackData.attackerAttackValue * attackData.attackerThunderDamagePercentage)) * (1f + attackData.addedAttackerThunderDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor.GetProperty("Actor_ResistAllElementAttackRatio")) * actor.GetProperty("Actor_ResistThunderAttackRatio")) * (1f + actor.GetProperty("Actor_ThunderAttackTakeRatio"));
attackData.iceDamage = (((((attackData.attackerIceDamage + (attackData.attackerAttackValue * attackData.attackerIceDamagePercentage)) * (1f + attackData.addedAttackerIceDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor.GetProperty("Actor_ResistAllElementAttackRatio")) * actor.GetProperty("Actor_ResistIceAttackRatio")) * (1f + actor.GetProperty("Actor_IceAttackTakeRatio"));
attackData.alienDamage = (((((attackData.attackerAlienDamage + (attackData.attackerAttackValue * attackData.attackerAlienDamagePercentage)) * (1f + attackData.addedAttackerAlienDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor.GetProperty("Actor_ResistAllElementAttackRatio")) * actor.GetProperty("Actor_ResistAllienAttackRatio")) * (1f + actor.GetProperty("Actor_AllienAttackTakeRatio"));
attackData.attackeeNature = (EntityNature)actor.avatarDataItem.Attribute;
attackData.attackeeClass = actor.config.CommonArguments.Class;
float num5 = GetNatureDamageBonusRatio(attackData.attackerNature, attackData.attackeeNature, actor);
float damageIncreaseRate = 0f;
if ((attackData.attackerCategory == 4) && flag)
{
damageIncreaseRate = AvatarDefencePunishMetaDataReader.GetAvatarDefencePunishMetaDataByKey(levelDifference).DamageIncreaseRate;
}
float num7 = Mathf.Clamp((float)(1f - attackData.attackerAddedAllDamageReduceRatio), (float)0f, (float)1f);
attackData.damage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.plainDamage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.fireDamage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.thunderDamage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.iceDamage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.alienDamage *= (num5 * (1f + damageIncreaseRate)) * num7;
attackData.natureDamageRatio = num5;
if (!Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID))
{
attackData.attackCameraShake = null;
}
attackData.attackeeAniDefenceRatio += actor.GetProperty("Actor_AniDefenceDelta");
}
else if (to is MonsterActor)
{
MonsterActor actor2 = (MonsterActor)to;
int num8 = Mathf.Clamp(((int)actor2.level) - Singleton <PlayerModule> .Instance.playerData.teamLevel, 0, 10);
if ((attackData.attackerCategory == 3) && Singleton <LevelScoreManager> .Instance.IsAllowLevelPunish())
{
attackData.attackerAniDamageRatio *= 1f - AvatarAttackPunishMetaDataReader.GetAvatarAttackPunishMetaDataByKey(num8).AttackRatioReduce;
}
attackData.attackeeAniDefenceRatio = GetAnimDefenceRatio(actor2);
attackData.damage = (((attackData.attackerAttackValue * attackData.attackerAttackPercentage) + attackData.attackerAddedAttackValue) * (1f + attackData.addedAttackRatio)) * (1f + attackData.addedDamageRatio);
float num9 = (actor2.defense + actor2.GetProperty("Actor_DefenceDelta")) * (1f + actor2.GetProperty("Actor_DefenceRatio"));
float num10 = GetDefenceRatio(num9, attackData.attackerLevel);
float num11 = (1f - num10) * actor2.GetProperty("Actor_DamageReduceRatio");
attackData.attackeeAddedDamageTakeRatio += actor2.GetProperty("Actor_DamageTakeRatio");
attackData.damage = (attackData.damage * num11) * (1f + attackData.attackeeAddedDamageTakeRatio);
attackData.plainDamage = (((((attackData.attackerNormalDamage + (attackData.attackerAttackValue * attackData.attackerNormalDamagePercentage)) * (1f + attackData.addedAttackerNormalDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor2.GetProperty("Actor_ResistAllElementAttackRatio")) * actor2.GetProperty("Actor_ResistNormalAttackRatio")) * (1f + actor2.GetProperty("Actor_NormalAttackTakeRatio"));
attackData.fireDamage = (((((attackData.attackerFireDamage + (attackData.attackerAttackValue * attackData.attackerFireDamagePercentage)) * (1f + attackData.addedAttackerFireDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor2.GetProperty("Actor_ResistAllElementAttackRatio")) * actor2.GetProperty("Actor_ResistFireAttackRatio")) * (1f + actor2.GetProperty("Actor_FireAttackTakeRatio"));
attackData.thunderDamage = (((((attackData.attackerThunderDamage + (attackData.attackerAttackValue * attackData.attackerThunderDamagePercentage)) * (1f + attackData.addedAttackerThunderDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor2.GetProperty("Actor_ResistAllElementAttackRatio")) * actor2.GetProperty("Actor_ResistThunderAttackRatio")) * (1f + actor2.GetProperty("Actor_ThunderAttackTakeRatio"));
attackData.iceDamage = (((((attackData.attackerIceDamage + (attackData.attackerAttackValue * attackData.attackerIceDamagePercentage)) * (1f + attackData.addedAttackerIceDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor2.GetProperty("Actor_ResistAllElementAttackRatio")) * actor2.GetProperty("Actor_ResistIceAttackRatio")) * (1f + actor2.GetProperty("Actor_IceAttackTakeRatio"));
attackData.alienDamage = (((((attackData.attackerAlienDamage + (attackData.attackerAttackValue * attackData.attackerAlienDamagePercentage)) * (1f + attackData.addedAttackerAlienDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor2.GetProperty("Actor_ResistAllElementAttackRatio")) * actor2.GetProperty("Actor_ResistAllienAttackRatio")) * (1f + actor2.GetProperty("Actor_AllienAttackTakeRatio"));
attackData.attackeeNature = (EntityNature)actor2.metaConfig.nature;
attackData.attackeeClass = actor2.config.CommonArguments.Class;
float num12 = GetNatureDamageBonusRatio(attackData.attackerNature, attackData.attackeeNature, actor2);
float damageReduceRate = 0f;
if ((attackData.attackerCategory == 3) && Singleton <LevelScoreManager> .Instance.IsAllowLevelPunish())
{
damageReduceRate = AvatarAttackPunishMetaDataReader.GetAvatarAttackPunishMetaDataByKey(num8).DamageReduceRate;
}
float num14 = Mathf.Clamp((float)(1f - attackData.attackerAddedAllDamageReduceRatio), (float)0f, (float)1f);
attackData.damage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.plainDamage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.fireDamage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.thunderDamage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.iceDamage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.alienDamage *= (num12 * (1f - damageReduceRate)) * num14;
attackData.natureDamageRatio = num12;
if (actor2.monster.IsAnimatorInTag(MonsterData.MonsterTagGroup.Throw))
{
attackData.retreatVelocity *= actor2.config.CommonArguments.BePushedSpeedRatioThrow;
}
else
{
attackData.retreatVelocity *= actor2.config.CommonArguments.BePushedSpeedRatio;
}
attackData.retreatVelocity *= 1f + actor2.GetProperty("Actor_BeRetreatRatio");
if (attackData.isAnimEventAttack && (UnityEngine.Random.value < attackData.attackerCritChance))
{
attackData.damage *= attackData.attackerCritDamageRatio;
attackData.hitLevel = AttackResult.ActorHitLevel.Critical;
}
attackData.attackeeAniDefenceRatio += actor2.GetProperty("Actor_AniDefenceDelta");
if (attackData.frameHalt > 1)
{
attackData.frameHalt += 2;
}
if ((attackData.attackeeAniDefenceRatio > attackData.attackerAniDamageRatio) && (attackData.frameHalt > 1))
{
attackData.frameHalt += attackData.noBreakFrameHaltAdd;
}
}
else if (to is PropObjectActor)
{
PropObjectActor actor3 = (PropObjectActor)to;
attackData.attackeeAniDefenceRatio = 0f;
attackData.beHitEffectPattern = actor3.config.BeHitEffect;
attackData.damage = (((attackData.attackerAttackValue * attackData.attackerAttackPercentage) + attackData.attackerAddedAttackValue) * (1f + attackData.addedAttackRatio)) * (1f + attackData.addedDamageRatio);
attackData.plainDamage = (((((attackData.attackerNormalDamage + (attackData.attackerAttackValue * attackData.attackerNormalDamagePercentage)) * (1f + attackData.addedAttackerNormalDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor3.GetProperty("Actor_ResistAllElementAttackRatio")) * actor3.GetProperty("Actor_ResistNormalAttackRatio")) * (1f + actor3.GetProperty("Actor_NormalAttackTakeRatio"));
attackData.fireDamage = (((((attackData.attackerFireDamage + (attackData.attackerAttackValue * attackData.attackerFireDamagePercentage)) * (1f + attackData.addedAttackerFireDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor3.GetProperty("Actor_ResistAllElementAttackRatio")) * actor3.GetProperty("Actor_ResistFireAttackRatio")) * (1f + actor3.GetProperty("Actor_FireAttackTakeRatio"));
attackData.thunderDamage = (((((attackData.attackerThunderDamage + (attackData.attackerAttackValue * attackData.attackerThunderDamagePercentage)) * (1f + attackData.addedAttackerThunderDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor3.GetProperty("Actor_ResistAllElementAttackRatio")) * actor3.GetProperty("Actor_ResistThunderAttackRatio")) * (1f + actor3.GetProperty("Actor_ThunderAttackTakeRatio"));
attackData.iceDamage = (((((attackData.attackerIceDamage + (attackData.attackerAttackValue * attackData.attackerIceDamagePercentage)) * (1f + attackData.addedAttackerIceDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor3.GetProperty("Actor_ResistAllElementAttackRatio")) * actor3.GetProperty("Actor_ResistIceAttackRatio")) * (1f + actor3.GetProperty("Actor_IceAttackTakeRatio"));
attackData.alienDamage = (((((attackData.attackerAlienDamage + (attackData.attackerAttackValue * attackData.attackerAlienDamagePercentage)) * (1f + attackData.addedAttackerAlienDamageRatio)) * (1f + attackData.addedDamageRatio)) * actor3.GetProperty("Actor_ResistAllElementAttackRatio")) * actor3.GetProperty("Actor_ResistAllienAttackRatio")) * (1f + actor3.GetProperty("Actor_AllienAttackTakeRatio"));
attackData.attackeeAniDefenceRatio += actor3.GetProperty("Actor_AniDefenceDelta");
if (attackData.frameHalt > 1)
{
attackData.frameHalt += 2;
}
}
attackData.resolveStep = AttackData.AttackDataStep.AttackeeResolved;
}
}
public MPAvatarActorPlugin(BaseActor actor)
{
this._actor = (AvatarActor)actor;
}
protected virtual void ProcessInitedActor(BaseActor actor)
{
}
