Exemple #1
0
 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;
 }
Exemple #4
0
 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);
     }
 }
Exemple #5
0
        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);
        }
Exemple #6
0
 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);
     }
 }
Exemple #7
0
 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();
 }
Exemple #8
0
        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);
        }
Exemple #11
0
        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());
        }
Exemple #12
0
        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);
        }
Exemple #13
0
        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);
        }
Exemple #14
0
        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);
        }
Exemple #15
0
        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);
        }
Exemple #16
0
        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);
        }
Exemple #17
0
        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);
        }
Exemple #18
0
        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);
        }
Exemple #20
0
 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);
        }
Exemple #24
0
        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();
        }
Exemple #25
0
 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;
 }
Exemple #26
0
        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);
 }