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) { }