示例#1
0
        public LevelElement GetHolder(MapHolderType type)
        {
            LevelElement holder = null;

            m_Holders.TryGetValue(type, out holder);
            return(holder);
        }
示例#2
0
        public void AddHolder <T>(MapHolderType type) where T : LevelElement
        {
            LevelElement holder = null;

            m_Holders.TryGetValue(type, out holder);
            if (holder == null)
            {
                holder          = new GameObject(typeof(T).Name).AddComponent <T>();
                m_Holders[type] = holder;
            }
        }
示例#3
0
        public override void OnInspectorGUI()
        {
            LevelElement pElem = target as LevelElement;
            int          pId   = EditorGUILayout.IntField("Id", pElem.Id);

            if (pElem.Id != pId)
            {
                pElem.Id = pId;
                pElem.SetName();
            }

            float pLifeTime = EditorGUILayout.FloatField("生命周期", pElem.LifeTime);

            if (pElem.LifeTime != pLifeTime)
            {
                pElem.LifeTime = pLifeTime;
            }
        }
示例#4
0
        private void InitLevelObject()
        {
            //触发区域
            for (int i = 0; i < Config.Regions.Count; i++)
            {
                MapRegion data = Config.Regions[i];
                if (data.StartActive)
                {
                    LevelElement pHolder = GetHolder(MapHolderType.Region);
                    GameObject   go      = pHolder.gameObject.AddChild();
                    LevelRegion  pRegion = go.AddComponent <LevelRegion>();
                    pRegion.Import(data, false);
                    pRegion.Init();
                }
            }

            //障碍物
            for (int i = 0; i < Config.Barriers.Count; i++)
            {
                MapBarrier   data     = Config.Barriers[i];
                LevelElement pHolder  = GetHolder(MapHolderType.Barrier);
                GameObject   go       = pHolder.gameObject.AddChild();
                LevelBarrier pBarrier = go.AddComponent <LevelBarrier>();
                pBarrier.Import(data, false);
                pBarrier.Init();
            }

            //传送门
            for (int i = 0; i < Config.Portals.Count; i++)
            {
                MapPortal    data    = Config.Portals[i];
                LevelElement pHolder = GetHolder(MapHolderType.Portal);
                GameObject   go      = pHolder.gameObject.AddChild();
                LevelPortal  pPortal = go.AddComponent <LevelPortal>();
                pPortal.Import(data, false);
                pPortal.Init();
            }
        }
示例#5
0
        private void Import()
        {
            LevelComponent levelCom = target as LevelComponent;

            levelCom.transform.DestroyChildren();
            levelCom.InitHolder();
            string    fsPath = AssetUtility.GetLevelConfigAsset(levelCom.LevelID.ToString());
            MapConfig data   = new MapConfig();

            data.EditorLoad(fsPath);

            levelCom.MapName = data.MapName;

            for (int i = 0; i < data.Regions.Count; i++)
            {
                LevelElement pHolder = levelCom.GetHolder(MapHolderType.Region);
                GameObject   go      = pHolder.gameObject.AddChild();
                LevelRegion  pRegion = go.AddComponent <LevelRegion>();
                pRegion.Import(data.Regions[i], true);
            }

            for (int i = 0; i < data.Barriers.Count; i++)
            {
                LevelElement pHolder  = levelCom.GetHolder(MapHolderType.Barrier);
                GameObject   go       = pHolder.gameObject.AddChild();
                LevelBarrier pBarrier = go.AddComponent <LevelBarrier>();
                pBarrier.Import(data.Barriers[i], true);
            }


            for (int i = 0; i < data.WaveSets.Count; i++)
            {
                LevelElement pHolder  = levelCom.GetHolder(MapHolderType.WaveSet);
                GameObject   go       = pHolder.gameObject.AddChild();
                LevelWaveSet pWaveSet = go.AddComponent <LevelWaveSet>();
                pWaveSet.Import(data.WaveSets[i], true);
            }

            for (int i = 0; i < data.MonsterGroups.Count; i++)
            {
                LevelElement      pHolder = levelCom.GetHolder(MapHolderType.MonsterGroup);
                GameObject        go      = pHolder.gameObject.AddChild();
                LevelMonsterGroup pGroup  = go.AddComponent <LevelMonsterGroup>();
                pGroup.Import(data.MonsterGroups[i], true);
            }

            for (int i = 0; i < data.MineGroups.Count; i++)
            {
                LevelElement   pHolder = levelCom.GetHolder(MapHolderType.MineGroup);
                GameObject     go      = pHolder.gameObject.AddChild();
                LevelMineGroup pGroup  = go.AddComponent <LevelMineGroup>();
                pGroup.Import(data.MineGroups[i], true);
            }

            for (int i = 0; i < data.Portals.Count; i++)
            {
                LevelElement pHolder = levelCom.GetHolder(MapHolderType.Portal);
                GameObject   go      = pHolder.gameObject.AddChild();
                LevelPortal  pPortal = go.AddComponent <LevelPortal>();
                pPortal.Import(data.Portals[i], true);
            }

            for (int i = 0; i < data.Npcs.Count; i++)
            {
                LevelElement pHolder = levelCom.GetHolder(MapHolderType.Npc);
                GameObject   go      = pHolder.gameObject.AddChild();
                LevelNpc     pNpc    = go.AddComponent <LevelNpc>();
                pNpc.Import(data.Npcs[i], true);
            }

            {
                LevelElement pHolder = levelCom.GetHolder(MapHolderType.Born);
                if (data.Ally != null)
                {
                    GameObject gA     = pHolder.gameObject.AddChild();
                    LevelBorn  pBornA = gA.AddComponent <LevelBorn>();
                    pBornA.Import(data.Ally, true);
                }
                if (data.Enemy != null)
                {
                    GameObject gB     = pHolder.gameObject.AddChild();
                    LevelBorn  pBornB = gB.AddComponent <LevelBorn>();
                    pBornB.Import(data.Enemy, true);
                }
                if (data.Neutral != null)
                {
                    GameObject gC     = pHolder.gameObject.AddChild();
                    LevelBorn  pBornC = gC.AddComponent <LevelBorn>();
                    pBornC.Import(data.Neutral, true);
                }
            }

            Debug.Log("导入关卡数据:" + fsPath);
        }
示例#6
0
        private MapConfig Export()
        {
            LevelComponent pHandler = target as LevelComponent;
            MapConfig      data     = new MapConfig();

            data.Id      = pHandler.LevelID;
            data.MapName = pHandler.MapName;
            data.MapPath = pHandler.MapPath;

            List <LevelElement> pList = new List <LevelElement>();

            for (int i = 0; i < pHandler.transform.childCount; i++)
            {
                Transform    child = pHandler.transform.GetChild(i);
                LevelElement pElem = child.GetComponent <LevelElement>();
                if (pElem)
                {
                    pList.Add(pElem);
                }
            }

            for (int k = 0; k < pList.Count; k++)
            {
                string       classType = pList[k].GetType().Name;
                LevelElement current   = pList[k];
                switch (classType)
                {
                case "HolderBorn":
                {
                    HolderBorn pHolder = current as HolderBorn;
                    if (pHolder != null)
                    {
                        for (int i = 0; i < pHolder.Elements.Count; i++)
                        {
                            LevelElement pElem = pHolder.Elements[i];
                            switch (pHolder.Elements[i].Camp)
                            {
                            case BattleCampType.Ally:
                                data.Ally = pElem.Export() as MapBorn;
                                break;

                            case BattleCampType.Enemy:
                                data.Enemy = pElem.Export() as MapBorn;
                                break;

                            case BattleCampType.Neutral:
                                data.Neutral = pElem.Export() as MapBorn;
                                break;
                            }
                        }
                    }
                }
                break;

                case "HolderBarrier":
                {
                    HolderBarrier pHolder = current as HolderBarrier;
                    if (pHolder != null)
                    {
                        for (int i = 0; i < pHolder.Elements.Count; i++)
                        {
                            LevelElement pElem = pHolder.Elements[i];
                            data.Barriers.Add(pElem.Export() as MapBarrier);
                        }
                    }
                }
                break;

                case "HolderPortal":
                {
                    HolderPortal pHolder = current as HolderPortal;
                    if (pHolder != null)
                    {
                        for (int i = 0; i < pHolder.Elements.Count; i++)
                        {
                            LevelElement pElem = pHolder.Elements[i];
                            data.Portals.Add(pElem.Export() as MapPortal);
                        }
                    }
                }
                break;

                case "HolderRegion":
                {
                    HolderRegion pHolder = current as HolderRegion;
                    if (pHolder != null)
                    {
                        for (int i = 0; i < pHolder.Elements.Count; i++)
                        {
                            LevelElement pElem = pHolder.Elements[i];
                            data.Regions.Add(pElem.Export() as MapRegion);
                        }
                    }
                }
                break;

                case "HolderWaveSet":
                {
                    HolderWaveSet pHolder = current as HolderWaveSet;
                    if (pHolder != null)
                    {
                        for (int i = 0; i < pHolder.Elements.Count; i++)
                        {
                            LevelElement pElem = pHolder.Elements[i];
                            data.WaveSets.Add(pElem.Export() as MapWaveSet);
                        }
                    }
                }
                break;

                case "HolderMonsterGroup":
                {
                    HolderMonsterGroup pHolder = current as HolderMonsterGroup;
                    if (pHolder != null)
                    {
                        for (int i = 0; i < pHolder.Elements.Count; i++)
                        {
                            LevelElement pElem = pHolder.Elements[i];
                            data.MonsterGroups.Add(pElem.Export() as MapMonsterGroup);
                        }
                    }
                }
                break;

                case "HolderMineGroup":
                {
                    HolderMineGroup pHolder = current as HolderMineGroup;
                    if (pHolder != null)
                    {
                        for (int i = 0; i < pHolder.Elements.Count; i++)
                        {
                            LevelElement pElem = pHolder.Elements[i];
                            data.MineGroups.Add(pElem.Export() as MapMineGroup);
                        }
                    }
                }
                break;

                case "HolderNpc":
                {
                    HolderNpc pHolder = current as HolderNpc;
                    if (pHolder != null)
                    {
                        for (int i = 0; i < pHolder.Elements.Count; i++)
                        {
                            LevelElement pElem = pHolder.Elements[i];
                            data.Npcs.Add(pElem.Export() as MapNpc);
                        }
                    }
                }
                break;
                }
            }
            return(data);
        }