public MonsterAIPlugin(MonsterActor owner)
{
this._owner = owner;
this._aiTree = this._owner.entity.GetComponent <BehaviorDesigner.Runtime.BehaviorTree>();
this._levelActor = Singleton <LevelManager> .Instance.levelActor;
this._threatTable = new SortedList <uint, int>();
}
private void OnUpdateAttackTarget(BaseMonoEntity entity)
{
if ((entity != null) && this._isTutorialAvailable)
{
MonsterActor attackee = Singleton <EventManager> .Instance.GetActor <MonsterActor>(entity.GetRuntimeID());
BaseMonoAvatar localAvatar = Singleton <AvatarManager> .Instance.GetLocalAvatar();
AvatarActor actor = Singleton <EventManager> .Instance.GetActor <AvatarActor>(localAvatar.GetRuntimeID());
EntityNature attackerNature = (EntityNature)attackee.metaConfig.nature;
EntityNature attribute = (EntityNature)actor.avatarDataItem.Attribute;
float num = DamageModelLogic.GetNatureDamageBonusRatio(attackerNature, attribute, attackee);
if (((((attackee != null) && (actor != null)) && ((base.step == 0) && (base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep))) && ((!this.IsAllStepDone() && (num > 1f)) && ((base.step == 0) && (base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep)))) && !this.IsAllStepDone())
{
this.ActiveCurrentStep();
this.WaitShowTutorialStep(this.GetDelayTime(base.step), new Action(this.ShowTutorialStep0));
}
if ((((attackee != null) && (actor != null)) && ((this._killAmount >= 2) && (this._monsterCreatedAmount > 2))) && (((num > 1f) && (base.step == 2)) && ((base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep) && !this.IsAllStepDone())))
{
this.ActiveCurrentStep();
this.WaitShowTutorialStep(this.GetDelayTime(base.step), new Action(this.ShowTutorialStep2));
}
}
}
public LevelTutorialPlayerTeaching(LevelTutorialHelperPlugin helper, LevelTutorialMetaData metaData) : base(helper, metaData)
{
this._finished = false;
this._witchTimeAttacking = false;
this._lastMonsterBorn = false;
this._witchTimeActor = null;
}
public AbilityShieldMixin(ActorAbility instancedAbility, ActorModifier instancedModifier, ConfigAbilityMixin config) : base(instancedAbility, instancedModifier, config)
{
this._shieldResumeRatio = 1f;
this.config = (ShieldMixin)config;
if (base.entity is BaseMonoMonster)
{
this._monsterEntity = (BaseMonoMonster)base.entity;
this._monsterActor = (MonsterActor)base.actor;
}
this._showShieldBar = instancedAbility.Evaluate(this.config.ShowShieldBar) != 0;
if (this.config.UseLevelTimeScale)
{
this._betweenAttackResumeTimer = new EntityTimer(this.config.BetweenAttackResumeCD);
this._forceResumeTimer = new EntityTimer(this.config.ForceResumeCD);
this._minForceResumeTimer = new EntityTimer(this.config.MinForceResumeCD);
this._shieldResumeTimer = new EntityTimer(this.config.ShieldResumeTimeSpan);
}
else
{
this._betweenAttackResumeTimer = new EntityTimer(this.config.BetweenAttackResumeCD, base.entity);
this._forceResumeTimer = new EntityTimer(this.config.ForceResumeCD, base.entity);
this._minForceResumeTimer = new EntityTimer(this.config.MinForceResumeCD, base.entity);
this._shieldResumeTimer = new EntityTimer(this.config.ShieldResumeTimeSpan, base.entity);
}
}
private bool SetupEliteIcon(MonsterActor monsterActor)
{
Transform trans = base.transform.Find("EliteIcons");
trans.DestroyChildren();
bool flag = false;
if (monsterActor.uniqueMonsterID > 0)
{
return(false);
}
foreach (ActorAbility ability in monsterActor.abilityPlugin.GetAppliedAbilities())
{
if ((ability != null) && (ability.config != null))
{
string abilityName = ability.config.AbilityName;
if (MiscData.Config.EliteAbilityIcon.ContainsKey(abilityName))
{
string str2 = MiscData.Config.EliteAbilityIcon[abilityName].ToString();
string textID = MiscData.Config.EliteAbilityText[abilityName].ToString();
if (!string.IsNullOrEmpty(str2))
{
GameObject obj2 = UnityEngine.Object.Instantiate <GameObject>(Miscs.LoadResource <GameObject>("UI/Menus/Widget/InLevel/EliteIcon", BundleType.RESOURCE_FILE));
obj2.transform.SetParent(trans, false);
obj2.transform.Find("Image").GetComponent <Image>().sprite = Miscs.GetSpriteByPrefab(str2);
obj2.transform.Find("Text").GetComponent <Text>().text = LocalizationGeneralLogic.GetText(textID, new object[0]);
flag = true;
}
}
}
}
trans.gameObject.SetActive(flag);
return(flag);
}
public override void Core()
{
this._suicideTimer.Core(1f);
this._warningTimer.Core(1f);
if (this._skinedMeshRenderer != null)
{
float t = this._warningTimer.timer / this._warningTimer.timespan;
float num2 = Mathf.Lerp(this._basicBrightness, 6f, t);
this._skinedMeshRenderer.sharedMaterial.SetFloat(this._brightnessPropertyName, num2);
}
if (this._warningTimer.isTimeUp)
{
this._warningTimer.timespan *= 0.9f;
this._warningTimer.timespan = Mathf.Max(0.1f, this._warningTimer.timespan);
this._warningTimer.Reset(true);
}
if (this._suicideTimer.isTimeUp)
{
MonsterActor actor = base.actor as MonsterActor;
actor.needDropReward = false;
actor.ForceKill(base.actor.runtimeID, KillEffect.KillImmediately);
this._suicideTimer.Reset(false);
this._warningTimer.Reset(false);
}
if (!string.IsNullOrEmpty(this._onTouchTriggerID))
{
base.actor.entity.ResetTrigger(this._onTouchTriggerID);
}
}
public void SetupView(MonsterActor monsterBefore, MonsterActor monsterAfter)
{
if (monsterBefore != null)
{
monsterBefore.onHPChanged = (Action <float, float, float>)Delegate.Remove(monsterBefore.onHPChanged, new Action <float, float, float>(this.UpdateMonsterHPBar));
monsterBefore.onMaxHPChanged = (Action <float, float>)Delegate.Remove(monsterBefore.onMaxHPChanged, new Action <float, float>(this.UpdateMonsterMaxHP));
if (monsterBefore.abilityPlugin.HasDisplayFloat("Shield"))
{
monsterBefore.abilityPlugin.SubDetachDisplayFloat("Shield", new Action <float, float>(this.UpdateMonsterShieldBar));
}
}
if (monsterAfter != null)
{
monsterAfter.onHPChanged = (Action <float, float, float>)Delegate.Combine(monsterAfter.onHPChanged, new Action <float, float, float>(this.UpdateMonsterHPBar));
monsterAfter.onMaxHPChanged = (Action <float, float>)Delegate.Combine(monsterAfter.onMaxHPChanged, new Action <float, float>(this.UpdateMonsterMaxHP));
base.gameObject.SetActive(true);
this.SetupHPBar(monsterAfter);
this.SetupShieldBar(monsterAfter);
if (!this.SetupEliteIcon(monsterAfter))
{
this.SetupNameText(monsterAfter);
}
else
{
base.transform.Find("NameText").gameObject.SetActive(false);
}
}
this._currentMonster = monsterAfter;
this.SetupNatureBonus();
this.SetupMonsterNameByLevelPunish();
}
public AbilityDefendModeMonsterMixin(ActorAbility instancedAbility, ActorModifier instancedModifier, ConfigAbilityMixin config) : base(instancedAbility, instancedModifier, config)
{
this._hatredAIAreaSections = new List <float>();
this._hatredAIValues = new List <int>();
this.config = (DefendModeMonsterMixin)config;
this._monsterActor = base.actor as MonsterActor;
this._monster = base.entity as BaseMonoMonster;
this._monsterHatredDic = new Dictionary <uint, float>();
this._monsterHatredDic.Clear();
this._hatredDecreaseTimer = new EntityTimer(instancedAbility.Evaluate(this.config.HatredDecreaseInterval));
this._hatredDecreaseTimer.Reset(false);
this._minAISwitchTimer = new EntityTimer(instancedAbility.Evaluate(this.config.MinAISwitchDuration));
this._minAISwitchTimer.Reset(false);
for (int i = 0; i < this.config.hatredAIAreaSections.Length; i++)
{
this._hatredAIAreaSections.Add(this.config.hatredAIAreaSections[i]);
}
this._hatredAIAreaSections.Add(1f);
for (int j = 0; j < this.config.hatredAIValues.Length; j++)
{
this._hatredAIValues.Add(this.config.hatredAIValues[j]);
}
this._defaultHatredAIValue = this.config.DefaultAIValue;
this._currentHatredAIValue = this._defaultHatredAIValue;
BTreeMonsterAIController activeAIController = (BTreeMonsterAIController)this._monster.GetActiveAIController();
if (activeAIController != null)
{
activeAIController.OnAIActive = (Action <bool>)Delegate.Combine(activeAIController.OnAIActive, new Action <bool>(this.OnMonsterAIActive));
}
}
private bool ListenKilled(EvtKilled evt)
{
AvatarActor actor = Singleton <EventManager> .Instance.GetActor <AvatarActor>(evt.killerID);
MonsterActor actor2 = Singleton <EventManager> .Instance.GetActor <MonsterActor>(evt.targetID);
MonoMainCamera mainCamera = Singleton <CameraManager> .Instance.GetMainCamera();
if ((((actor != null) && (actor2 != null)) && (Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID) && (Singleton <MonsterManager> .Instance.LivingMonsterCount() == 0))) && mainCamera.followState.slowMotionKillState.active)
{
if (string.IsNullOrEmpty(evt.killerAnimEventID) || !actor.config.AnimEvents.ContainsKey(evt.killerAnimEventID))
{
return(false);
}
AttackResult.AttackCategoryTag[] categoryTag = actor.config.AnimEvents[evt.killerAnimEventID].AttackProperty.CategoryTag;
if (categoryTag == null)
{
return(false);
}
bool flag = false;
for (int i = 0; i < categoryTag.Length; i++)
{
if (categoryTag[i] == AttackResult.AttackCategoryTag.SwitchIn)
{
flag = true;
break;
}
}
if (flag)
{
this.Finish();
}
}
return(false);
}
private bool CheckAllowFollow()
{
MonsterActor actor = base.actor as MonsterActor;
if (actor != null)
{
string currentSkillID = actor.monster.CurrentSkillID;
if (string.IsNullOrEmpty(currentSkillID))
{
return(false);
}
if (this.config.SkillIDs == null)
{
return(false);
}
if (base.actor.abilityState.ContainsState(AbilityState.Paralyze) || base.actor.abilityState.ContainsState(AbilityState.Stun))
{
return(false);
}
int index = 0;
int length = this.config.SkillIDs.Length;
while (index < length)
{
if (currentSkillID == this.config.SkillIDs[index])
{
return(true);
}
index++;
}
}
return(false);
}
public uint CreateMonster(string monsterName, string typeName, int level, bool isLocal, Vector3 initPos, uint runtimeID, bool isElite = false, uint uniqueMonsterID = 0, bool checkOutsideWall = true, bool disableBehaviorWhenInit = false, int tagID = 0)
{
BaseMonoMonster component = null;
GameObject gameObj = null;
if (uniqueMonsterID != 0)
{
UniqueMonsterMetaData uniqueMonsterMetaData = MonsterData.GetUniqueMonsterMetaData(uniqueMonsterID);
monsterName = uniqueMonsterMetaData.monsterName;
typeName = uniqueMonsterMetaData.typeName;
}
string str = monsterName + typeName + uniqueMonsterID.ToString() + disableBehaviorWhenInit.ToString();
int index = 0;
int num2 = 0;
int count = this._preloadedMonsters.Count;
while (num2 < count)
{
if (this._preloadedMonsters[num2].name == str)
{
gameObj = this._preloadedMonsters[num2].gameObj;
index = num2;
break;
}
num2++;
}
if (gameObj != null)
{
gameObj.SetActive(true);
this._preloadedMonsters.RemoveAt(index);
}
else
{
gameObj = (GameObject)UnityEngine.Object.Instantiate(Miscs.LoadResource <GameObject>(MonsterData.GetPrefabResPath(monsterName, typeName, !GlobalVars.MONSTER_USE_DYNAMIC_BONE || (Singleton <LevelManager> .Instance.levelActor.levelMode == LevelActor.Mode.Multi)), BundleType.RESOURCE_FILE), InLevelData.CREATE_INIT_POS, Quaternion.identity);
}
component = gameObj.GetComponent <BaseMonoMonster>();
if (runtimeID == 0)
{
runtimeID = Singleton <RuntimeIDManager> .Instance.GetNextRuntimeID(4);
}
bool flag = checkOutsideWall;
component.Init(monsterName, typeName, runtimeID, initPos, uniqueMonsterID, null, flag, isElite, disableBehaviorWhenInit, tagID);
this.RegisterMonster(component);
MonsterActor actor = Singleton <EventManager> .Instance.CreateActor <MonsterActor>(component);
actor.InitLevelData(level, isElite);
actor.PostInit();
int num4 = 0;
int length = component.config.CommonArguments.RequestSoundBankNames.Length;
while (num4 < length)
{
Singleton <WwiseAudioManager> .Instance.ManualPrepareBank(component.config.CommonArguments.RequestSoundBankNames[num4]);
num4++;
}
return(component.GetRuntimeID());
}
public override TaskStatus OnUpdate()
{
BaseMonoMonster component = base.GetComponent <BaseMonoMonster>();
MonsterActor actor = Singleton <EventManager> .Instance.GetActor <MonsterActor>(component.GetRuntimeID());
this.HPRatio.SetValue((float)(actor.HP / actor.maxHP));
return(TaskStatus.Success);
}
private bool IsMonsterDeadKillerWithTeleportSkill(MonsterActor monsterActor)
{
bool flag = false;
if (((monsterActor != null) && (monsterActor.metaConfig.subTypeName == this._monsterSubTypeName)) && (monsterActor.metaConfig.configType == this._monsterConfigTypeName))
{
flag = true;
}
return(flag);
}
private bool ListenMonsterCreated(EvtMonsterCreated evt)
{
MonsterActor actor = Singleton <EventManager> .Instance.GetActor <MonsterActor>(evt.monsterID);
if ((((actor != null) && (actor.metaConfig.subTypeName == this._monsterSubTypeName)) && ((base.step == 0) && (base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep))) && !this.IsAllStepDone())
{
this.WaitShowTutorialStep(this.GetDelayTime(base.step), new Action(this.ShowTutorialStep1));
}
return(false);
}
private bool ListenAttackStart(EvtAttackStart evt)
{
MonsterActor actor = Singleton <EventManager> .Instance.GetActor <MonsterActor>(evt.targetID);
if ((((actor != null) && (actor.metaConfig.subTypeName == this._monsterSubTypeName)) && ((actor.entity.CurrentSkillID == "DEF_ATK") && (base.step == 1))) && ((base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep) && !this.IsAllStepDone()))
{
this.ActiveCurrentStep();
this.WaitShowTutorialStep(this.GetDelayTime(base.step), new Action(this.ShowTutorialStep2));
}
return(false);
}
private bool ListenTeleport(EvtTeleport evt)
{
MonsterActor monsterActor = Singleton <EventManager> .Instance.GetActor <MonsterActor>(evt.targetID);
if ((((monsterActor != null) && this.IsMonsterDeadKillerWithTeleportSkill(monsterActor)) && ((base.step == 1) && (base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep))) && !this.IsAllStepDone())
{
this.ActiveCurrentStep();
this.WaitShowTutorialStep(this.GetDelayTime(base.step), new Action(this.ShowTutorialStep2));
}
return(false);
}
private bool ListenShieldBroken(EvtShieldBroken evt)
{
MonsterActor actor = Singleton <EventManager> .Instance.GetActor <MonsterActor>(evt.targetID);
if ((((actor != null) && actor.isElite) && ((base.step == 1) && (base.GetCurrentStepState() == BaseLevelTutorial.StepState.Sleep))) && !this.IsAllStepDone())
{
this.ActiveCurrentStep();
this.WaitShowTutorialStep(0.5f, new Action(this.ShowTutorialStep2));
}
return(false);
}
private void SetupHPBar(MonsterActor monsterActor)
{
int newMaxPhase = 1;
if (monsterActor.uniqueMonsterID > 0)
{
UniqueMonsterMetaData uniqueMonsterMetaData = MonsterData.GetUniqueMonsterMetaData(monsterActor.uniqueMonsterID);
newMaxPhase = (uniqueMonsterMetaData != null) ? uniqueMonsterMetaData.hpPhaseNum : 1;
}
this._hpSlider.UpdateMaxPhase(newMaxPhase);
this._hpSlider.UpdateValue((float)monsterActor.HP, (float)monsterActor.maxHP, 0f);
}
public override void OnAbilityTriggered(EvtAbilityStart evt)
{
Vector3 vector;
if (this._blackHoleTimer.isActive)
{
this.KillBlackHole(true);
}
BaseMonoEntity entity = null;
if (evt.otherID != 0)
{
BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.otherID);
if ((actor != null) && (actor.entity != null))
{
entity = actor.entity;
}
}
if (entity != null)
{
vector = entity.XZPosition + new Vector3(0f, 0.5f, 0f);
}
else
{
Vector3 origin = base.entity.XZPosition + new Vector3(0f, 0.5f, 0f);
vector = CollisionDetectPattern.GetRaycastPoint(origin, base.entity.transform.forward, base.instancedAbility.Evaluate(this.config.CreationZOffset), 0.2f, ((int)1) << InLevelData.STAGE_COLLIDER_LAYER);
}
this._fieldActor = Singleton <DynamicObjectManager> .Instance.CreateAbilityTriggerField(vector, base.entity.transform.forward, base.actor, base.instancedAbility.Evaluate(this.config.Radius), MixinTargetting.Enemy, Singleton <DynamicObjectManager> .Instance.GetNextSyncedDynamicObjectRuntimeID(), false);
if ((this.config.CreationEffect != null) && (this.config.CreationEffect.EffectPattern != null))
{
this._blackHoleEffectIx = Singleton <EffectManager> .Instance.CreateIndexedEntityEffectPattern(this.config.CreationEffect.EffectPattern, this._fieldActor.triggerField);
}
if (this.config.ApplyAttackerWitchTimeRatio && (evt.TriggerEvent != null))
{
EvtEvadeSuccess triggerEvent = evt.TriggerEvent as EvtEvadeSuccess;
if (triggerEvent != null)
{
MonsterActor actor2 = Singleton <EventManager> .Instance.GetActor <MonsterActor>(triggerEvent.attackerID);
if (actor2 != null)
{
ConfigMonsterAnimEvent event2 = SharedAnimEventData.ResolveAnimEvent(actor2.config, triggerEvent.skillID);
if (event2 != null)
{
this._blackHoleTimer.timespan *= event2.AttackProperty.WitchTimeRatio;
}
}
}
}
this._blackHoleTimer.Reset(true);
}
public void InitFromMonsterActor(MonsterActor monsterActor, float hpRatioOfParent)
{
this.owner = monsterActor.monster;
this.ownerActor = monsterActor;
base.level = this.ownerActor.level;
base.attack = this.ownerActor.attack;
base.defense = this.ownerActor.defense;
base.HP = base.maxHP = hpRatioOfParent * monsterActor.maxHP;
base.monster.DisableShadow();
Physics.IgnoreCollision(this.owner.transform.GetComponent <Collider>(), base.monster.transform.GetComponent <Collider>());
base.monster.transform.position = this.owner.transform.position;
}
private bool IsMonsterBoss(MonsterActor monster)
{
if ((monster != null) && (monster.uniqueMonsterID > 0))
{
UniqueMonsterMetaData uniqueMonsterMetaData = MonsterData.GetUniqueMonsterMetaData(monster.uniqueMonsterID);
if ((uniqueMonsterMetaData != null) && (uniqueMonsterMetaData.hpPhaseNum > 1))
{
return(true);
}
}
return(false);
}
public void OnTargetMonsterChange(MonsterActor targetBefore, MonsterActor targetAfter)
{
this.localAvatarLockedMonsterActor = targetAfter;
if (this.IsLocalAvatarLockedMonsterBoss())
{
this.SetAllSubHPBarDisable();
}
if ((this.localAvatarLockedMonsterActor != null) && this._subMonsterHPBarMap.ContainsKey(this.localAvatarLockedMonsterActor.runtimeID))
{
this._subMonsterHPBarMap[this.localAvatarLockedMonsterActor.runtimeID].SetDisable();
}
}
private bool ListenKilled(EvtKilled evt)
{
AvatarActor actor = Singleton <EventManager> .Instance.GetActor <AvatarActor>(evt.killerID);
MonsterActor actor2 = Singleton <EventManager> .Instance.GetActor <MonsterActor>(evt.targetID);
if (((actor != null) && (actor2 != null)) && this._inStastics)
{
int num = this._killedAmountLs.SeekAddPosition <Tuple <float, int> >();
this._killedAmountLs[num] = Tuple.Create <float, int>(this._stasticsTimer, 1);
}
return(false);
}
public override void Init()
{
this._monster = Singleton <MonsterManager> .Instance.GetMonsterByRuntimeID(base.runtimeID);
this._monsterActor = Singleton <MPEventManager> .Instance.GetActor <MonsterActor>(base.runtimeID);
base._animatorEntity = this._monster;
base._abilityEntity = this._monster;
base._abilityActor = this._monsterActor;
this._monsterActor.GetPlugin <MPMonsterActorPlugin>().SetupIdentity(this);
this._monsterActor.GetPluginAs <ActorAbilityPlugin, MPActorAbilityPlugin>().SetupIdentity(this);
base.Init();
}
public void SetupView(AvatarActor attacker, MonsterActor attackee, float offset, Action <MonoSubMonsterHPBar> hideHPBarCallBack = null)
{
base.gameObject.SetActive(true);
if (!this.attackerSet.Contains(attacker.runtimeID))
{
this.attackerSet.Add(attacker.runtimeID);
}
this.attackee = attackee;
this._offset = offset;
this.enable = true;
this._monster = attackee.entity as BaseMonoMonster;
this._hideHPBarCallBack = hideHPBarCallBack;
}
private void SetupShieldBar(MonsterActor monsterActor)
{
bool flag = monsterActor.abilityPlugin.HasDisplayFloat("Shield");
base.transform.Find("ShieldBar").gameObject.SetActive(flag);
if (flag)
{
float curValue = 0f;
float ceiling = 0f;
float floor = 0f;
monsterActor.abilityPlugin.SubAttachDisplayFloat("Shield", new Action <float, float>(this.UpdateMonsterShieldBar), ref curValue, ref floor, ref ceiling);
this._shieldSlider.UpdateValue(curValue, ceiling, floor);
}
}
private void AddQTETarget(MonsterActor actor)
{
bool flag = true;
foreach (QTETarget target in this._qteTargetList)
{
if (target.monsterActor == actor)
{
flag = false;
}
}
if (flag)
{
this._qteTargetList.Add(new QTETarget(actor));
}
}
private bool ListenKilled(EvtKilled evt)
{
AvatarActor actor = Singleton <EventManager> .Instance.GetActor <AvatarActor>(evt.killerID);
MonsterActor actor2 = Singleton <EventManager> .Instance.GetActor <MonsterActor>(evt.targetID);
if (((actor != null) && (actor2 != null)) && Singleton <AvatarManager> .Instance.IsLocalAvatar(actor.runtimeID))
{
this._tempKilledNum++;
if (this._tempKilledNum >= this.targetKilledNum)
{
this.Finish();
}
}
return(false);
}
private MonsterStastics GetMonsterStastics(uint monsterRuntimeID)
{
MonsterActor actor = Singleton <EventManager> .Instance.GetActor <MonsterActor>(monsterRuntimeID);
if (actor == null)
{
return(null);
}
BaseMonoMonster monster = actor.monster;
if (!this._monsterStasticsDict.ContainsKey(monsterRuntimeID))
{
this._monsterStasticsDict[monsterRuntimeID] = new MonsterStastics(monster.MonsterName, monster.TypeName, (int)actor.level);
}
return(this._monsterStasticsDict[monsterRuntimeID]);
}
private bool CheckMaintainCondition(QTECondition qteCondition)
{
if (!Singleton <AvatarManager> .Instance.IsLocalAvatar(this._avatarActor.runtimeID))
{
if (Singleton <EventManager> .Instance.GetActor <AvatarActor>(Singleton <AvatarManager> .Instance.GetLocalAvatar().GetRuntimeID()).MuteOtherQTE)
{
return(false);
}
for (int i = 0; i < this._qteTargetList.Count; i++)
{
QTETarget target = this._qteTargetList[i];
target.Core();
if (!target.CanCheck())
{
return(true);
}
MonsterActor monsterActor = target.monsterActor;
if (((monsterActor != null) && (monsterActor.isAlive != 0)) && this.QTERangeCheck(monsterActor, qteCondition.QTERange))
{
if (qteCondition.QTEType == QTEConditionType.QTEAnimationTag)
{
for (int j = 0; j < qteCondition.QTEValues.Length; j++)
{
MonsterData.MonsterTagGroup tagGroup = (MonsterData.MonsterTagGroup)((int)Enum.Parse(typeof(MonsterData.MonsterTagGroup), qteCondition.QTEValues[j]));
if (monsterActor.monster.IsAnimatorInTag(tagGroup))
{
return(true);
}
}
}
else if (qteCondition.QTEType == QTEConditionType.QTEBuffTag)
{
for (int k = 0; k < qteCondition.QTEValues.Length; k++)
{
AbilityState state = (AbilityState)((int)Enum.Parse(typeof(AbilityState), qteCondition.QTEValues[k]));
if ((monsterActor.abilityState & state) != AbilityState.None)
{
return(true);
}
}
}
}
}
}
return(false);
}
