public void UpdateLevelGroup_Ideal_ShouldInsertSuccessfully()
        {
            // #1 Insert
            // arrange
            var levelGroupService = ContainerManager.ResolveUnregistered <LevelGroupService>();
            var group             = new LevelGroup()
            {
                Name = "Group test",
                PV   = 100
            };

            // act
            levelGroupService.InsertLevelGroup(group);

            // assert
            Assert.Greater(group.Id, 0); // id will be generated when inserting successfully

            // #2 Update
            // arrange
            var savedGroup = levelGroupService.GetLevelGroupById(group.Id);

            savedGroup.Name = "Updated group";
            savedGroup.PV   = 120;

            // act
            levelGroupService.UpdateLevelGroup(savedGroup);
            var updatedGroup = levelGroupService.GetLevelGroupById(group.Id);

            // assert
            Assert.AreEqual("Updated group", updatedGroup.Name);
            Assert.AreEqual(120, updatedGroup.PV);

            // clean up
            CleanUp(levelGroupService, group);
        }
        /* Method to update the tab pane contents. */
        void tab_update(LevelGroup lg)
        {
            EventHandler           updateHandler     = delegate(object sender, EventArgs args) { tab_update(lg); };
            FormClosedEventHandler formClosedHandler = delegate(object sender, FormClosedEventArgs args) { tab_update(lg); };

            Module[] modlist = course.getModules(lg.level);

            /* Remove controls... */
            foreach (ModuleControlGroup mcg in lg.levelControlGroups)
            {
                mcg.removeControls();
            }
            lg.levelControlGroups.Clear();

            lg.credits = Course.sumModuleCredit(modlist);
            //Point cur = lg.tabpanel.Location;
            Point cur = new Point(0, 0);

            foreach (Module m in modlist)
            {
                ModuleControlGroup mcg = new ModuleControlGroup(formClosedHandler, updateHandler, course, lg.level, 120 - lg.credits, m, lg.tabpanel);
                mcg.addControls(cur, out cur);
                lg.levelControlGroups.Add(mcg);
            }
        }
Esempio n. 3
0
    /// <summary>
    /// Reset values and remove any spawned level components
    /// </summary>
    private void CleanUp()
    {
        // Reset to default values
        mLevelSwitchPulse  = LevelGroupSwitchTime;
        mCurrentLevelGroup = StartingLevelGroup;
        mNumLevelSwitches  = 0;

        // Clean out some other values
        mLastCenterPosition = Vector3.zero;

        // Clear out all components
        LevelComponent currentComponent;

        while (mLevelComponentQueue.Count > 0)
        {
            currentComponent = mLevelComponentQueue.Dequeue();
            currentComponent.Destroy();
        }

        // go through all level groups and reset
        foreach (LevelGroup lvGroup in LevelGroups)
        {
            lvGroup.Reset();
        }
    }
    void Awake()
    {
        LoadGameData();

        SceneManager.LoadScene(levelGroups[0].sceneName, LoadSceneMode.Additive);
        currentGroup = levelGroups[0];
    }
    IEnumerator WaitToFillGroup(long numberOf, LevelGroup currentGroup, int stageNumber, List <GameObject> floorGameobjects, List <int> ids)
    {
        yield return(StartCoroutine(LoadAllAssetsByKey(numberOf, currentGroup, stageNumber)));

        DoGameobjectsFillUp(currentGroup, floorGameobjects, ids);
        Debug.Log(currentGroup.LevelGroupScenes[0]);
    }
    private IEnumerator UnloadCurrentScene(LevelGroup newGroup, int caseNumber)
    {
        AsyncOperation async = SceneManager.UnloadSceneAsync(currentGroup.sceneName);

        yield return(async);

        StartCoroutine(LoadNextScene(newGroup, caseNumber));
    }
    private IEnumerator LoadNextScene(LevelGroup newGroup, int caseNumber)
    {
        AsyncOperation async = SceneManager.LoadSceneAsync(newGroup.sceneName, LoadSceneMode.Additive);

        yield return(async);

        LoadCase(PMWrapper.currentLevel, caseNumber);
    }
    public void OnPMCaseSwitched(int caseNumber)
    {
        LevelGroup newGroup = GetGroup(PMWrapper.currentLevel);

        if (currentGroup.sceneName != newGroup.sceneName)
        {
            StartCoroutine(UnloadCurrentScene(newGroup, caseNumber));
            currentGroup = newGroup;
        }
        else
        {
            LoadCase(PMWrapper.currentLevel, caseNumber);
        }
    }
Esempio n. 9
0
    public override void OnInspectorGUI()
    {
        serializedObject.Update();
        list.DoLayoutList();
        serializedObject.ApplyModifiedProperties();

        LevelGroup myScript = (LevelGroup)target;

        myScript.folderName = EditorGUILayout.TextField("Folder Name", myScript.folderName);
        if (GUILayout.Button("Sync List"))
        {
            myScript.SyncList();
        }
    }
Esempio n. 10
0
 void backToMap()
 {
     if (transitionState.overworldParent.activeSelf)
     {
         startP = camTrans.position;
         lerpTimer.turnTimerOn();
     }
     else
     {
         int        groupId = transitionState.levelObjects[(int)transitionState.currentLevelType].GetComponent <BoardLogic>().groupId;
         LevelGroup group   = transitionState.levelGroups[groupId];
         TransitionState.OverworldTransLevelData data = new TransitionState.OverworldTransLevelData(transitionState.currentLevelType, group.GetPos(transitionState));
         transitionState.SetTransition_(transitionState.BackToWorldTransition, data);
     }
 }
Esempio n. 11
0
        public void Awake()
        {
            levelObjects = new GameObject[(int)LevelType.LEVEL_COUNT];
            saveStates   = new SaveState[(int)LevelType.LEVEL_COUNT];
            levelGroups  = new LevelGroup[(int)LevelType.LEVEL_COUNT];
            for (int i = 0; i < levelGroups.Length; ++i)
            {
                levelGroups[i] = new LevelGroup();
            }
            LoadSaveFile();

            overworldStars      = new ClickLevel[(int)LevelType.LEVEL_COUNT];
            levelPosInOverworld = new Vector3[(int)LevelType.LEVEL_COUNT];

            DontDestroyOnLoad(gameObject);
        }
Esempio n. 12
0
    /// <summary>
    /// Transitions to random new level group.
    /// </summary>
    private void TransitionToRandomNewLevelGroup()
    {
        // Cut to a new, different level that has the proper level ID.
        // Update our level switches
        mNumLevelSwitches++;

        // Pull out all levels that are 'legal' to switch to
        List <LevelGroup> potentialLevels = new List <LevelGroup>();

        foreach (LevelGroup levelGroup in LevelGroups)
        {
            if (levelGroup != mCurrentLevelGroup &&        // Don't switch to the current group
                levelGroup.levelGroupDifficulty <= mNumLevelSwitches)                // Dont switch to a group that is a higher 'level' then us
            {
                potentialLevels.Add(levelGroup);
            }
        }

        if (potentialLevels.Count > 0)
        {
            // Choose a random level
            int        randomIndex   = Random.Range(0, potentialLevels.Count);
            LevelGroup newLevelGroup = potentialLevels[randomIndex];
            LevelGroup.eLevelGroupID currentGroupID = mCurrentLevelGroup.LevelGroupID;
            LevelGroup.eLevelGroupID newGroupID     = newLevelGroup.LevelGroupID;

            // Transition!
            mCurrentLevelGroup = newLevelGroup;
            Debug.Log("Transitioning to level " + newLevelGroup.LevelGroupID);

            // Now that we succesfully transitioned, determine if there is a level transition component.
            foreach (LevelTransitionComponent currentTransition in LevelTransitionGroups)
            {
                if (currentTransition.FromGroupID == currentGroupID &&
                    currentTransition.ToGroupID == newGroupID)
                {
                    // Push this component nowww
                    PushAndInstantiateRandomComponent(currentTransition);
                }
            }
        }
        else
        {
            Debug.LogError("No other levels to switch to. Perhaps there are no other level groups, or we havent reached a new "
                           + "level number yet? Current number transitions: " + mNumLevelSwitches);
        }
    }
        public MainPage()
        {
            state = new GPAState();
            fileexists = state.load(filepath);
            course = state.getCourse();

            InitializeComponent();

            level4Group = new LevelGroup(Level.LEVEL_4, Tab4ModulePanel);
            level5Group = new LevelGroup(Level.LEVEL_5, Tab5ModulePanel);
            level6Group = new LevelGroup(Level.LEVEL_6, Tab6ModulePanel);

            level4SummaryGroups = new List<SummaryModuleGroup>();
            level5SummaryGroups = new List<SummaryModuleGroup>();
            level6SummaryGroups = new List<SummaryModuleGroup>();

            tabControl1.Selected += new TabControlEventHandler(tabControl1_Selected);
        }
        public MainPage()
        {
            state      = new GPAState();
            fileexists = state.load(filepath);
            course     = state.getCourse();

            InitializeComponent();

            level4Group = new LevelGroup(Level.LEVEL_4, Tab4ModulePanel);
            level5Group = new LevelGroup(Level.LEVEL_5, Tab5ModulePanel);
            level6Group = new LevelGroup(Level.LEVEL_6, Tab6ModulePanel);


            level4SummaryGroups = new List <SummaryModuleGroup>();
            level5SummaryGroups = new List <SummaryModuleGroup>();
            level6SummaryGroups = new List <SummaryModuleGroup>();

            tabControl1.Selected += new TabControlEventHandler(tabControl1_Selected);
        }
Esempio n. 15
0
        public async Task <JsonResult> AddLevelGroup([FromBody] LevelGroup levelGroup)
        {
            try
            {
                _context.Add(levelGroup);
                await _context.SaveChangesAsync();

                return(Json(new ApiMessage
                {
                    HasError = false,
                    Message = "Success"
                }));
            }
            catch (Exception e)
            {
                return(Json(new ApiMessage
                {
                    HasError = true,
                    Message = e.Message
                }));
            }
        }
    private void DoGameobjectsFillUp(LevelGroup currentGroup, List <GameObject> floorGameobjects, List <int> ids)
    {
        foreach (int id in ids)
        {
            Debug.LogWarning("ids:" + id);
        }
        Debug.LogWarning(currentGroup.levelName);
        foreach (GameObject ob in currentGroup.LevelGroupScenes)
        {
            Debug.LogWarning("currentGroup.LevelGroupScenes:" + ob);
        }

        for (int i = 0; i < currentGroup.LevelGroupScenes.Count; i++)
        {
            for (int j = 0; j < ids.Count; j++)
            {
                if (currentGroup.LevelGroupScenes[i].GetComponent <Room>().GetId == ids[j])
                {
                    floorGameobjects.Add(currentGroup.LevelGroupScenes[i]);
                }
            }
        }
    }
Esempio n. 17
0
    private void LoadLevel(int level)
    {
        var levelPrefab = Resources.Load <Transform>("LevelGroup/LevelGroup_" + level);

        if (levelPrefab == null)
        {
            //通关
            GameWin();
            return;
        }
        if (CurrLevelGroup != null)
        {
            Destroy(CurrLevelGroup.gameObject);
        }
        var lg = Instantiate(levelPrefab);

        CurrLevelGroup = lg.GetComponent <LevelGroup>();
        var playerBorn = lg.GetComponentInChildren <PlayerBornPoint>();

        PlayerRobot.GetComponent <Robot.RobotCharacterController>().Teleport(
            playerBorn.transform.position, playerBorn.transform.rotation);

        Destroy(playerBorn.gameObject);
    }
Esempio n. 18
0
        /// <summary>
        /// Combines multiple templates into a single level group.
        /// </summary>
        /// <param name="templateNames">The comma-delimited string of template names.</param>
        public LevelGroup[] Build(string templateNames)
        {
            // First check if the group has already been built
            LevelGroup[] combinedGroups;
            if (_templates.TryGetValue(templateNames, out combinedGroups))
                return combinedGroups;
            if (_cache.TryGetValue(templateNames, out combinedGroups))
                return combinedGroups;

            // This list exists to preserve the order of groups. 
            // An ordered dictionary would work too, but this is easier.
            var groupNames = new List<string>();
            var groupMap = new Dictionary<string, List<Level>>();
            var defaultGroup = new List<Level>();
            string[] splitTemplateNames = templateNames.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string templateName in splitTemplateNames)
            {
                // Get the template that we're building off of
                LevelGroup[] groups;
                if (!_templates.TryGetValue(templateName, out groups))
                    throw new ConfigLoadException("Attempting to use undefined level template: " + templateName);

                foreach (LevelGroup group in groups)
                {
                    string groupName = group.Name;
                    if (groupName == null)
                    {
                        defaultGroup.AddRange(group);
                    }
                    else
                    {
                        List<Level> levels;

                        // Check if the group already exists.
                        // If so, just keep appending to that group, 
                        // otherwise, create a new group.
                        if (!groupMap.TryGetValue(groupName, out levels))
                        {
                            levels = new List<Level>();
                            groupMap.Add(groupName, levels);
                            groupNames.Add(groupName);
                        }

                        // We won't check for duplicate levels here, 
                        // since it adds too much complexity and isn't 
                        // really that large of an issue anyways.
                        levels.AddRange(group);
                    }
                }
            }

            // Make sure we're not combining templates with and without groups
            if (defaultGroup.Count > 0 && groupNames.Count > 0)
                throw new ConfigLoadException("Cannot combine templates unless either all or none have groups");

            if (defaultGroup.Count > 0)
            {
                // All templates have no groups
                combinedGroups = new[] { new LevelGroup(null, defaultGroup.ToArray()) };
            }
            else
            {
                // All templates have groups
                // Convert each level list to a LevelGroup object
                combinedGroups = new LevelGroup[groupNames.Count];
                for (int i = 0; i < combinedGroups.Length; ++i)
                {
                    string groupName = groupNames[i];
                    Level[] groupLevels = groupMap[groupName].ToArray();
                    combinedGroups[i] = new LevelGroup(groupName, groupLevels);
                }
            }

            // Add the group to the cache for faster future processing
            _cache.Add(templateNames, combinedGroups);
            return combinedGroups;
        }
    public void DeserializeSeed(string seed)
    {
        string s1 = seed.Substring(0, 2);
        string s2 = seed.Substring(2, 2);
        string s3 = seed.Substring(4, 2);
        string s4 = seed.Substring(6, 2);
        string s5 = seed.Substring(8, 2);

        seed = seed.Substring(10);
        string lvl1 = seed.Substring(0, System.Convert.ToInt16(s1) * 2);

        seed = seed.Substring(System.Convert.ToInt16(s1) * 2);
        string lvl2 = seed.Substring(0, System.Convert.ToInt16(s2) * 2);

        seed = seed.Substring(System.Convert.ToInt16(s2) * 2);
        string lvl3 = seed.Substring(0, System.Convert.ToInt16(s3) * 2);

        seed = seed.Substring(System.Convert.ToInt16(s3) * 2);
        string lvl4 = seed.Substring(0, System.Convert.ToInt16(s4) * 2);

        seed = seed.Substring(System.Convert.ToInt16(s4) * 2);
        string lvl5 = seed.Substring(0, System.Convert.ToInt16(s5) * 2);

        print(lvl1);
        print(lvl2);
        print(lvl3);
        print(lvl4);
        print(lvl5);

        List <int> lvl1_int        = new List <int>();
        int        internalCounter = 1;
        int        len             = lvl1.Length;

        for (int i = 0; i < len; i++)
        {
            if (internalCounter == 2)
            {
                lvl1_int.Add(int.Parse(lvl1.Substring(0, internalCounter)));
                lvl1            = lvl1.Substring(internalCounter);
                internalCounter = 0;
            }
            internalCounter++;
        }
        LevelGroup groupLabelOne = new LevelGroup();

        scenesFloorOne = new List <GameObject>();
        StartCoroutine(WaitToFillGroup(long.Parse(s1), groupLabelOne, 1, scenesFloorOne, lvl1_int));
        print("lvl1int: " + lvl1_int);

        List <int> lvl2_int = new List <int>();

        internalCounter = 1;
        len             = lvl2.Length;
        for (int i = 0; i < len; i++)
        {
            if (internalCounter == 2)
            {
                lvl2_int.Add(int.Parse(lvl2.Substring(0, internalCounter)));
                lvl2            = lvl2.Substring(internalCounter);
                internalCounter = 0;
            }
            internalCounter++;
        }
        LevelGroup groupLabelTwo = new LevelGroup();

        scenesFloorTwo = new List <GameObject>();
        StartCoroutine(WaitToFillGroup(long.Parse(s2), groupLabelTwo, 2, scenesFloorTwo, lvl2_int));
        print("lvl2int: " + lvl2_int);

        List <int> lvl3_int = new List <int>();

        internalCounter = 1;
        len             = lvl3.Length;
        for (int i = 0; i < len; i++)
        {
            if (internalCounter == 2)
            {
                lvl3_int.Add(int.Parse(lvl3.Substring(0, internalCounter)));
                lvl3            = lvl3.Substring(internalCounter);
                internalCounter = 0;
            }
            internalCounter++;
        }
        LevelGroup groupLabelThree = new LevelGroup();

        scenesFloorThree = new List <GameObject>();
        StartCoroutine(WaitToFillGroup(long.Parse(s3), groupLabelThree, 3, scenesFloorThree, lvl3_int));
        print("lvl3int: " + lvl3_int);

        List <int> lvl4_int = new List <int>();

        internalCounter = 1;
        len             = lvl4.Length;
        for (int i = 0; i < len; i++)
        {
            if (internalCounter == 2)
            {
                lvl4_int.Add(int.Parse(lvl4.Substring(0, internalCounter)));
                lvl4            = lvl4.Substring(internalCounter);
                internalCounter = 0;
            }
            internalCounter++;
        }
        LevelGroup groupLabelFour = new LevelGroup();

        scenesFloorFour = new List <GameObject>();
        StartCoroutine(WaitToFillGroup(long.Parse(s4), groupLabelFour, 4, scenesFloorFour, lvl4_int));
        print("lvl4int: " + lvl4_int);

        List <int> lvl5_int = new List <int>();

        internalCounter = 1;
        len             = lvl5.Length;
        for (int i = 0; i < len; i++)
        {
            if (internalCounter == 2)
            {
                lvl5_int.Add(int.Parse(lvl5.Substring(0, internalCounter)));
                lvl5            = lvl5.Substring(internalCounter);
                internalCounter = 0;
            }
            internalCounter++;
        }
        LevelGroup groupLabelFive = new LevelGroup();

        scenesFloorFive = new List <GameObject>();
        StartCoroutine(WaitToFillGroup(long.Parse(s5), groupLabelFive, 5, scenesFloorFive, lvl5_int));
        print("lvl5int: " + lvl5_int);
    }
    ///<sumary>
    ///Will load all objects that match the given key.If this key is an Addressable label, it will load all assets marked with that label
    ///</sumary>
    public IEnumerator LoadAllAssetsByKey(long numberOf, LevelGroup currentGroup, int stageNumber)
    {
        AsyncOperationHandle <IList <GameObject> > loadFirsts = Addressables.LoadAssetsAsync <GameObject>("StartRoom", asset => { });
        // AsyncOperationHandle<IList<GameObject>> loadBosses = Addressables.LoadAssetsAsync<GameObject>("BossRoom", asset => { });
        AsyncOperationHandle <IList <GameObject> > loadWithSingleKeyHandle = Addressables.LoadAssetsAsync <GameObject>("Stage" + stageNumber, asset => { });

        yield return(loadFirsts);

        // yield return loadBosses;
        yield return(loadWithSingleKeyHandle);

        // IList<GameObject> stageFirstsResult = loadFirsts.Result;
        // IList<GameObject> stageBossesResult = loadBosses.Result;
        // IList<GameObject> stageAllScenesResult = loadWithSingleKeyHandle.Result;
        IList <GameObject> stageAllScenesResult = fakeAdresseables.GetStagePrefabs(stageNumber);
        IList <GameObject> stageFirstsResult    = fakeAdresseables.GetStageFirstPrefabs();

        // IList<GameObject> stageBossesResult = loadBosses.Result;


        if (stageFirstsResult.Count > 1)
        {
            stageFirstsResult.Shuffle();
        }
        // if (stageBossesResult.Count > 1)
        //     stageBossesResult.Shuffle();


        if (numberOf > stageAllScenesResult.Count)
        {
            numberOf = stageAllScenesResult.Count;
        }
        for (int i = 0; i < numberOf; i++)
        {
            if (currentGroup.LevelGroupScenes.Contains(stageAllScenesResult[i]))
            {
                Debug.Log("ALREADY IN");
            }
            else
            {
                currentGroup.LevelGroupScenes.Add(stageAllScenesResult[i]);
            }
        }
        currentGroup.LevelGroupScenes.Shuffle();
        GameObject firstScene, bossScene;

        foreach (GameObject first in stageFirstsResult)
        {
            if (currentGroup.LevelGroupScenes.Contains(first))
            {
                firstScene = first;
                currentGroup.LevelGroupScenes.Remove(first);
                currentGroup.LevelGroupScenes.Insert(0, firstScene);
                firstScene.GetComponent <Room>().SetisStartingRoom = true;
                break;
            }
        }
        // foreach (GameObject boss in stageBossesResult)
        // {
        //     if (currentGroup.LevelGroupScenes.Contains(boss))
        //     {
        //         bossScene = boss;
        //         currentGroup.LevelGroupScenes.Remove(boss);
        //         currentGroup.LevelGroupScenes.Add(bossScene);
        //         bossScene.GetComponent<Room>().SetIsBossRoom = true;
        //         break;
        //     }
        // }
    }
Esempio n. 21
0
        /// <summary>
        /// Constructs a new course object.
        /// </summary>
        /// <param name="name">The name of the course.</param>
        /// <param name="credits">The credit value of the course.</param>
        /// <param name="groups">An array containing the level groups of the course.</param>
        /// <param name="scoreTable">The table that maps scores to GPA values.</param>
        public StaticCourse(string name, double credits, LevelGroup[] groups, ScoreTable scoreTable)
        {
            if (name == null)
                throw new ArgumentNullException("name");
            if (credits <= 0)
                throw new ArgumentOutOfRangeException("credits");
            if (groups == null)
                throw new ArgumentNullException("groups");
            if (groups.Length == 0)
                throw new ArgumentException("Must provide at least one level group");
            if (scoreTable == null)
                throw new ArgumentNullException("scoreTable");
            _name = name;
            _credits = credits;
            _groups = groups;
            _scoreTable = scoreTable;

            LevelGroup group = groups[0];
            _selectedLevelGroup = group;
            _selectedLevel = group.LevelCount > 0 ? group[0] : null;

            NameTranslator = x => x;
        }
Esempio n. 22
0
        private static void LoadCourse(XElement courseConfigElement, Course course)
        {
            // Sub-course
            DynamicCourse dynamicCourse = course as DynamicCourse;

            if (dynamicCourse != null)
            {
                string selectedCourseStr = XmlHelper.GetElementValueOrDefault(courseConfigElement, "selected");
                if (selectedCourseStr != null)
                {
                    StaticCourse selected = dynamicCourse.Courses.FirstOrDefault(c => c.RawName == selectedCourseStr);
                    if (selected != null)
                    {
                        dynamicCourse.SelectedCourse = selected;
                    }
                }
            }

            // Enabled
            string enabledStr = XmlHelper.GetElementValueOrDefault(courseConfigElement, "enabled");
            bool   enabled;

            if (bool.TryParse(enabledStr, out enabled))
            {
                course.Enabled = enabled;
            }

            // Group
            if (course.GroupCount > 0)
            {
                string groupStr = XmlHelper.GetElementValueOrDefault(courseConfigElement, "group");
                if (groupStr != null)
                {
                    LevelGroup group = course.FirstOrDefault(g => g.RawName == groupStr);
                    if (group != null)
                    {
                        course.SelectedLevelGroup = group;
                    }
                }
            }

            // Level
            if (course.SelectedLevelGroup.LevelCount > 0)
            {
                string levelStr = XmlHelper.GetElementValueOrDefault(courseConfigElement, "level");
                if (levelStr != null)
                {
                    Level level = course.SelectedLevelGroup.FirstOrDefault(l => l.RawName == levelStr);
                    if (level != null)
                    {
                        course.SelectedLevel = level;
                    }
                }
            }

            // Score
            string scoreStr = XmlHelper.GetElementValueOrDefault(courseConfigElement, "score");

            if (scoreStr != null)
            {
                course.Score = scoreStr;
            }
        }
        /* Method to update the tab pane contents. */
        void tab_update(LevelGroup lg)
        {
            EventHandler updateHandler = delegate(object sender, EventArgs args) { tab_update(lg); };
            FormClosedEventHandler formClosedHandler = delegate(object sender, FormClosedEventArgs args) { tab_update(lg); };
            Module[] modlist = course.getModules(lg.level);

            /* Remove controls... */
            foreach (ModuleControlGroup mcg in lg.levelControlGroups)
            {
                mcg.removeControls();
            }
            lg.levelControlGroups.Clear();

            lg.credits = Course.sumModuleCredit(modlist);
            //Point cur = lg.tabpanel.Location;
            Point cur = new Point(0, 0);
            foreach(Module m in modlist)
            {
                ModuleControlGroup mcg = new ModuleControlGroup(formClosedHandler, updateHandler, course, lg.level, 120 - lg.credits, m, lg.tabpanel);
                mcg.addControls(cur, out cur);
                lg.levelControlGroups.Add(mcg);
            }
        }
 private void FillUpSceneGroups(int numberOf, LevelGroup currentGroup) //aquí es donde aparecería lo "procedural" en el stageNumber....
 {
     Debug.Log(currentGroup.levelName + ":" + sceneGroups.IndexOf(currentGroup) + 1);
     StartCoroutine(DataController.Instance.LoadAllAssetsByKey(numberOf, currentGroup, (sceneGroups.IndexOf(currentGroup) + 1)));
 }
Esempio n. 25
0
 public void InsertLevelGroup(LevelGroup group)
 {
     _levelGroupRepository.Insert(@group);
 }
Esempio n. 26
0
 public string GroupName(LevelGroup group)
 {
     return GetLocalizedString(LocalizedStrings.GroupName, group.Name);
 }
Esempio n. 27
0
        public JsonResult AddLevelGroup(string BigLevel, string ProjectID, string SmallLevel)
        {
            LevelGroup p = new LevelGroup();
            p.BigLevel = BigLevel;
            p.SmallLevel = SmallLevel;
            p.ProjectOid = Int32.Parse(ProjectID);

            try
            {
                new LevelGroupDao().Insert(p);
            }
            catch (Exception e)
            {
                return Json(e.Message);
            }
            return Json("插入成功");
        }
Esempio n. 28
0
 public void UpdateLevelGroup(LevelGroup group)
 {
     _levelGroupRepository.Update(group);
 }
Esempio n. 29
0
 public string GroupName(LevelGroup group)
 {
     return(GetLocalizedString(LocalizedStrings.GroupName, group.Name));
 }
 private void CleanUp(ILevelGroupService levelGroupService, LevelGroup group)
 {
     levelGroupService.DeleteLevelGroup(group.Id);
 }
Esempio n. 31
0
        /// <summary>
        /// Combines multiple templates into a single level group.
        /// </summary>
        /// <param name="templateNames">The comma-delimited string of template names.</param>
        public LevelGroup[] Build(string templateNames)
        {
            // First check if the group has already been built
            LevelGroup[] combinedGroups;
            if (_templates.TryGetValue(templateNames, out combinedGroups))
            {
                return(combinedGroups);
            }
            if (_cache.TryGetValue(templateNames, out combinedGroups))
            {
                return(combinedGroups);
            }

            // This list exists to preserve the order of groups.
            // An ordered dictionary would work too, but this is easier.
            var groupNames   = new List <string>();
            var groupMap     = new Dictionary <string, List <Level> >();
            var defaultGroup = new List <Level>();

            string[] splitTemplateNames = templateNames.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
            foreach (string templateName in splitTemplateNames)
            {
                // Get the template that we're building off of
                LevelGroup[] groups;
                if (!_templates.TryGetValue(templateName, out groups))
                {
                    throw new ConfigLoadException("Attempting to use undefined level template: " + templateName);
                }

                foreach (LevelGroup group in groups)
                {
                    string groupName = group.Name;
                    if (groupName == null)
                    {
                        defaultGroup.AddRange(group);
                    }
                    else
                    {
                        List <Level> levels;

                        // Check if the group already exists.
                        // If so, just keep appending to that group,
                        // otherwise, create a new group.
                        if (!groupMap.TryGetValue(groupName, out levels))
                        {
                            levels = new List <Level>();
                            groupMap.Add(groupName, levels);
                            groupNames.Add(groupName);
                        }

                        // We won't check for duplicate levels here,
                        // since it adds too much complexity and isn't
                        // really that large of an issue anyways.
                        levels.AddRange(group);
                    }
                }
            }

            // Make sure we're not combining templates with and without groups
            if (defaultGroup.Count > 0 && groupNames.Count > 0)
            {
                throw new ConfigLoadException("Cannot combine templates unless either all or none have groups");
            }

            if (defaultGroup.Count > 0)
            {
                // All templates have no groups
                combinedGroups = new[] { new LevelGroup(null, defaultGroup.ToArray()) };
            }
            else
            {
                // All templates have groups
                // Convert each level list to a LevelGroup object
                combinedGroups = new LevelGroup[groupNames.Count];
                for (int i = 0; i < combinedGroups.Length; ++i)
                {
                    string  groupName   = groupNames[i];
                    Level[] groupLevels = groupMap[groupName].ToArray();
                    combinedGroups[i] = new LevelGroup(groupName, groupLevels);
                }
            }

            // Add the group to the cache for faster future processing
            _cache.Add(templateNames, combinedGroups);
            return(combinedGroups);
        }