コード例 #1
0
ファイル: MonoDevLevel.cs プロジェクト: slb1988/agame
 private void PostAwakeTryLoadFromFile()
 {
     if (DevLevelConfigData.configFromScene)
     {
         this.TryDestroyTypeAll <BaseMonoAvatar>();
         this.TryDestroyTypeAll <BaseMonoMonster>();
         this.TryDestroyTypeAll <MonoBasePerpStage>();
         this.TryDestroyTypeAll <MonoStageEnv>();
         Resources.UnloadUnusedAssets();
         GC.Collect();
         GC.WaitForPendingFinalizers();
         StageEntry stageEntryByName = StageData.GetStageEntryByName(this.stageDevData.stageName);
         GameObject obj2             = UnityEngine.Object.Instantiate <GameObject>(Miscs.LoadResource <GameObject>(stageEntryByName.GetPerpStagePrefabPath(), BundleType.RESOURCE_FILE));
         obj2.transform.position = Vector3.zero;
         Transform transform = obj2.transform;
         transform.position -= obj2.transform.Find(stageEntryByName.LocationPointName).position;
         StageManager.SetPerpstageNodeVisibility(obj2.GetComponent <MonoBasePerpStage>(), stageEntryByName, false, false);
         StageManager.SetPerpstageNodeVisibility(obj2.GetComponent <MonoBasePerpStage>(), stageEntryByName, true, true);
         UnityEngine.Object.Instantiate <GameObject>(Miscs.LoadResource <GameObject>(stageEntryByName.GetEnvPrefabPath(), BundleType.RESOURCE_FILE));
         DevAvatarData data = this.avatarDevDatas[0];
         UnityEngine.Object.Instantiate <GameObject>(Miscs.LoadResource <GameObject>(AvatarData.GetPrefabResPath(data.avatarType, false), BundleType.RESOURCE_FILE));
         this.monsterInstanceIds = new List <int>();
         foreach (DevMonsterData data2 in this.monsterDevDatas)
         {
             this.monsterInstanceIds.Add(UnityEngine.Object.Instantiate <GameObject>(Miscs.LoadResource <GameObject>(MonsterData.GetPrefabResPath(data2.monsterName, data2.typeName, false), BundleType.RESOURCE_FILE)).GetInstanceID());
         }
     }
 }
コード例 #2
0
ファイル: MonoDevLevel.cs プロジェクト: slb1988/agame
        private void HandleAlreadyLoadedPrefabs()
        {
            RuntimeIDManager  instance         = Singleton <RuntimeIDManager> .Instance;
            StageEntry        stageEntryByName = StageData.GetStageEntryByName(this.stageDevData.stageName);
            MonoBasePerpStage perpStage        = UnityEngine.Object.FindObjectOfType <MonoBasePerpStage>();

            if (perpStage != null)
            {
                perpStage.Init(stageEntryByName, (string)null);
            }
            MonoStageEnv stageEnv = UnityEngine.Object.FindObjectOfType <MonoStageEnv>();

            Singleton <StageManager> .Instance.RegisterStage(stageEntryByName, perpStage, stageEnv);

            LevelActor actor = (LevelActor)Singleton <EventManager> .Instance.GetActor(0x21800001);

            actor.levelMode = this.LEVEL_MODE;
            BaseMonoAvatar avatar = UnityEngine.Object.FindObjectOfType <BaseMonoAvatar>();

            if (avatar != null)
            {
                DevAvatarData  devAvatarData  = this.avatarDevDatas[0];
                AvatarDataItem avatarDataItem = Singleton <AvatarModule> .Instance.GetDummyAvatarDataItem(this.avatarTypeNames[0], devAvatarData.avatarLevel, devAvatarData.avatarStar);

                this.SetUpAvatarDataItem(avatarDataItem, devAvatarData);
                uint nextRuntimeID = instance.GetNextRuntimeID(3);
                avatar.Init(true, nextRuntimeID, avatarDataItem.AvatarRegistryKey, avatarDataItem.GetWeapon().ID, avatar.transform.position, avatar.transform.forward, true);
                this.LoadAvatarWwiseSoundBank(avatar);
                AvatarActor actor2 = Singleton <EventManager> .Instance.CreateActor <AvatarActor>(avatar);

                actor2.InitAvatarDataItem(avatarDataItem, true, false, true, true);
                actor2.PostInit();
                Singleton <AvatarManager> .Instance.RegisterAvatar(avatar, true, true, false);

                this.SetUpAvatarSkill(actor2, devAvatarData);
                this.CheatForPariticleMode(actor2);
                for (int i = 1; i < this.avatarCount; i++)
                {
                    DevAvatarData  data2 = this.avatarDevDatas[i];
                    AvatarDataItem item2 = Singleton <AvatarModule> .Instance.GetDummyAvatarDataItem(this.avatarTypeNames[i], data2.avatarLevel, data2.avatarStar);

                    this.SetUpAvatarDataItem(item2, data2);
                    uint runtimeID = instance.GetNextRuntimeID(3);
                    Singleton <AvatarManager> .Instance.CreateAvatar(item2, false, avatar.XZPosition, avatar.FaceDirection, runtimeID, false, false, false, false);

                    AvatarActor actor3 = Singleton <EventManager> .Instance.GetActor <AvatarActor>(runtimeID);

                    this.SetUpAvatarSkill(actor3, data2);
                    this.CheatForPariticleMode(actor3);
                }
                if (this.useFakeHelper)
                {
                    this.CreateFakeFriendAvatar();
                }
                Singleton <CinemaDataManager> .Instance.Preload(avatar);
            }
            foreach (BaseMonoMonster monster in UnityEngine.Object.FindObjectsOfType <BaseMonoMonster>())
            {
                DevMonsterData data3      = null;
                int            instanceID = monster.gameObject.GetInstanceID();
                for (int j = 0; j < this.monsterInstanceIds.Count; j++)
                {
                    if (this.monsterInstanceIds[j] == instanceID)
                    {
                        data3 = this.monsterDevDatas[j];
                        break;
                    }
                }
                if (data3 == null)
                {
                    UnityEngine.Object.Destroy(monster.gameObject);
                }
                else
                {
                    string monsterName;
                    string typeName;
                    uint   num7 = instance.GetNextRuntimeID(4);
                    if (data3.uniqueMonsterID != 0)
                    {
                        UniqueMonsterMetaData uniqueMonsterMetaData = MonsterData.GetUniqueMonsterMetaData(data3.uniqueMonsterID);
                        monsterName = uniqueMonsterMetaData.monsterName;
                        typeName    = uniqueMonsterMetaData.typeName;
                    }
                    else
                    {
                        monsterName = data3.monsterName;
                        typeName    = data3.typeName;
                    }
                    bool isElite = data3.isElite;
                    monster.Init(monsterName, typeName, num7, monster.transform.position, data3.uniqueMonsterID, null, true, isElite, true, 0);
                    for (int k = 0; k < monster.config.CommonArguments.RequestSoundBankNames.Length; k++)
                    {
                        Singleton <WwiseAudioManager> .Instance.ManualPrepareBank(monster.config.CommonArguments.RequestSoundBankNames[k]);
                    }
                    MonsterActor actor4 = Singleton <EventManager> .Instance.CreateActor <MonsterActor>(monster);

                    actor4.InitLevelData(data3.level, data3.isElite);
                    actor4.PostInit();
                    Singleton <MonsterManager> .Instance.RegisterMonster(monster);

                    if (data3.abilities.Length > 0)
                    {
                        for (int m = 0; m < data3.abilities.Length; m++)
                        {
                            string str3 = data3.abilities[m];
                            if (!string.IsNullOrEmpty(str3))
                            {
                                actor4.abilityPlugin.InsertPreInitAbility(AbilityData.GetAbilityConfig(data3.abilities[m]));
                            }
                        }
                    }
                    if (data3.isStationary)
                    {
                        MonsterActor actor5 = Singleton <EventManager> .Instance.GetActor <MonsterActor>(monster.GetRuntimeID());

                        actor5.baseMaxHP = actor5.HP = actor5.maxHP = 999999f;
                        monster.GetActiveAIController().SetActive(false);
                    }
                }
            }
            Singleton <LevelManager> .Instance.levelActor.SuddenLevelStart();

            EvtStageReady evt = new EvtStageReady {
                isBorn = true
            };

            Singleton <EventManager> .Instance.FireEvent(evt, MPEventDispatchMode.Normal);

            Singleton <DetourManager> .Instance.LoadNavMeshRelatedLevel(this.stageDevData.stageName);

            Singleton <MainUIManager> .Instance.GetInLevelUICanvas().FadeInStageTransitPanel(0.18f, false, null, null);
        }
コード例 #3
0
ファイル: MonsterManager.cs プロジェクト: slb1988/agame
        public uint CreateMonsterMirror(BaseMonoMonster owner, Vector3 initPos, Vector3 initDir, string AIName, float hpRatio, bool disableBehaviorWhenInit = false)
        {
            BaseMonoMonster component = ((GameObject)UnityEngine.Object.Instantiate(Miscs.LoadResource <GameObject>(MonsterData.GetPrefabResPath(owner.MonsterName, owner.TypeName, false), BundleType.RESOURCE_FILE), initPos, Quaternion.LookRotation(initDir))).GetComponent <BaseMonoMonster>();
            bool            flag      = disableBehaviorWhenInit;

            component.Init(owner.MonsterName, owner.TypeName, Singleton <RuntimeIDManager> .Instance.GetNextRuntimeID(4), initPos, owner.uniqueMonsterID, AIName, true, false, flag, 0);
            this.RegisterMonster(component);
            MonsterMirrorActor actor = Singleton <EventManager> .Instance.CreateActor <MonsterMirrorActor>(component);

            actor.InitFromMonsterActor(Singleton <EventManager> .Instance.GetActor <MonsterActor>(owner.GetRuntimeID()), hpRatio);
            actor.PostInit();
            int index  = 0;
            int length = component.config.CommonArguments.RequestSoundBankNames.Length;

            while (index < length)
            {
                Singleton <WwiseAudioManager> .Instance.ManualPrepareBank(component.config.CommonArguments.RequestSoundBankNames[index]);

                index++;
            }
            return(component.GetRuntimeID());
        }
コード例 #4
0
ファイル: MonsterManager.cs プロジェクト: slb1988/agame
        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());
        }
コード例 #5
0
ファイル: MonsterManager.cs プロジェクト: slb1988/agame
        public void PreloadMonster(string monsterName, string typeName, uint uniqueMonsterID = 0, bool disableBehaviorWhenInit = false)
        {
            string name = monsterName + typeName + uniqueMonsterID.ToString() + disableBehaviorWhenInit.ToString();

            for (int i = 0; i < this._preloadedMonsters.Count; i++)
            {
                if ((this._preloadedMonsters[i].name == name) && !this._preloadedMonsters[i].occupied)
                {
                    this._preloadedMonsters[i].occupied = true;
                    return;
                }
            }
            GameObject      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);
            BaseMonoMonster component = gameObj.GetComponent <BaseMonoMonster>();

            component.PreInit(monsterName, typeName, uniqueMonsterID, disableBehaviorWhenInit);
            gameObj.SetActive(false);
            PreloadMonsterItem item = new PreloadMonsterItem(name, gameObj, component.config);

            this._preloadedMonsters.Add(item);
            ConfigMonster monster2 = MonsterData.GetMonsterConfig(monsterName, typeName, string.Empty);

            for (int j = 0; j < monster2.CommonArguments.PreloadEffectPatternGroups.Length; j++)
            {
                Singleton <EffectManager> .Instance.PreloadEffectGroup(monster2.CommonArguments.PreloadEffectPatternGroups[j], false);
            }
            for (int k = 0; k < monster2.CommonArguments.RequestSoundBankNames.Length; k++)
            {
                Singleton <WwiseAudioManager> .Instance.ManualPrepareBank(component.config.CommonArguments.RequestSoundBankNames[k]);
            }
        }
コード例 #6
0
ファイル: MonsterActor.cs プロジェクト: slb1988/agame
 private void InitUniqueMonsterConfig(NPCLevelMetaData npcLevelMetaData)
 {
     if (this.uniqueMonsterID != 0)
     {
         UniqueMonsterMetaData uniqueMonsterMetaData = MonsterData.GetUniqueMonsterMetaData(this.uniqueMonsterID);
         base.baseMaxHP = base.maxHP = base.HP = (this.metaConfig.HP * uniqueMonsterMetaData.HPRatio) * npcLevelMetaData.HPRatio;
         base.defense   = (this.metaConfig.defense * uniqueMonsterMetaData.defenseRatio) * npcLevelMetaData.DEFRatio;
         base.attack    = (this.metaConfig.attack * uniqueMonsterMetaData.attackRatio) * npcLevelMetaData.ATKRatio;
         if (uniqueMonsterMetaData.abilities.Length > 0)
         {
             LuaState state = new LuaState();
             IDictionaryEnumerator enumerator = ((LuaTable)state.DoString(uniqueMonsterMetaData.abilities)[0]).GetEnumerator();
             try
             {
                 while (enumerator.MoveNext())
                 {
                     ConfigAbility   abilityConfig;
                     DictionaryEntry current     = (DictionaryEntry)enumerator.Current;
                     string          key         = (string)current.Key;
                     LuaTable        table2      = (LuaTable)current.Value;
                     string          monsterName = uniqueMonsterMetaData.monsterName;
                     if (monsterName == null)
                     {
                         abilityConfig = AbilityData.GetAbilityConfig(key);
                     }
                     else
                     {
                         abilityConfig = AbilityData.GetAbilityConfig(key, monsterName);
                     }
                     Dictionary <string, object> dictionary  = new Dictionary <string, object>();
                     IDictionaryEnumerator       enumerator2 = table2.GetEnumerator();
                     try
                     {
                         while (enumerator2.MoveNext())
                         {
                             DictionaryEntry entry2 = (DictionaryEntry)enumerator2.Current;
                             string          str3   = (string)entry2.Key;
                             if (entry2.Value is double)
                             {
                                 dictionary.Add(str3, (float)((double)entry2.Value));
                             }
                             else if (entry2.Value is string)
                             {
                                 dictionary.Add(str3, (string)entry2.Value);
                             }
                         }
                     }
                     finally
                     {
                         IDisposable disposable = enumerator2 as IDisposable;
                         if (disposable == null)
                         {
                         }
                         disposable.Dispose();
                     }
                     base.appliedAbilities.Add(Tuple.Create <ConfigAbility, Dictionary <string, object> >(abilityConfig, dictionary));
                 }
             }
             finally
             {
                 IDisposable disposable2 = enumerator as IDisposable;
                 if (disposable2 == null)
                 {
                 }
                 disposable2.Dispose();
             }
         }
     }
 }