public static Scene CreateEmptyScene(string sceneName, string parentFolderName)
{
GameLevelToolkitWindow toolkit = GameLevelToolkitWindow.GetRefreshedToolkitWindow();
string projectDirectory = null;
if (toolkit.settings == null)
{
projectDirectory = toolkit.projectDirectoryPathName;
}
else
{
projectDirectory = GameLevelToolkitWindow.GetProjectPathStringWithSlash();
}
if (!Directory.Exists("Assets/" + projectDirectory + "Scenes/" + SceneAndResourceFolderName.folderNameValue + "/" + parentFolderName))
{
AssetDatabase.CreateFolder("Assets/" + projectDirectory + "Scenes/" + SceneAndResourceFolderName.folderNameValue, parentFolderName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
string fullSceneDirectory = "Assets/" + projectDirectory + "Scenes/" + SceneAndResourceFolderName.folderNameValue + "/" + parentFolderName + "/";
Scene newScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
newScene.name = sceneName;
EditorSceneManager.SaveScene(newScene, fullSceneDirectory + sceneName + ".unity");
return(newScene);
}
public static GameLevelToolkitWindow GetRefreshedToolkitWindow()
{
if (toolkitWindow == null)
{
toolkitWindow = (GameLevelToolkitWindow)GetWindow(typeof(GameLevelToolkitWindow), false, "Game Level Toolkit");
}
toolkitWindow.settings = GetGameLevelToolkitSettings();
toolkitWindow.gameLevelsData = GetGameLevelsData();
if (toolkitWindow.gameLevelsData == null || toolkitWindow.settings == null)
{
toolkitWindow.initialDataHasBeenCreated = false;
}
else
{
toolkitWindow.initialDataHasBeenCreated = true;
toolkitWindow.levelsDataObj = toolkitWindow.gameLevelsData;
toolkitWindow.settingsObj = toolkitWindow.settings;
}
//Check If Initial Required Data Has Been Created
if (toolkitWindow.initialDataHasBeenCreated == true)
{
toolkitWindow.initialDataHasBeenCreated = toolkitWindow.gameLevelsData.initialDataHasBeenCreated;
}
return(toolkitWindow);
}
public static GameLevel[] GetGameLevelsBasedOnCategory(string categoryName)
{
GameLevelData data = GameLevelToolkitWindow.GetGameLevelsData();
List <GameLevel> categories = new List <GameLevel>();
if (categoryName == data.allCategoriesName) // Get All
{
for (int i = 0; i < data.gameLevelsCreatedByUser.Count; i++)
{
categories.Add(data.gameLevelsCreatedByUser[i]);
}
}
else // Get By Name
{
for (int i = 0; i < data.gameLevelsCreatedByUser.Count; i++)
{
if (data.gameLevelsCreatedByUser[i].assignedCategory == categoryName)
{
categories.Add(data.gameLevelsCreatedByUser[i]);
}
}
}
return(categories.ToArray());
}
public static void CreateCategory(string targetName)
{
GameLevelData data = GameLevelToolkitWindow.GetGameLevelsData();
data.allUserCreatedCategories.Add(targetName);
EditorUtility.SetDirty(data);
}
public static void AddMasterSceneToBuild()
{
List <EditorBuildSettingsScene> buildScenes = GetEditorBuildSettingsScenes();
//Add The Master Scene
string masterscenePath = "Assets/" + GameLevelToolkitWindow.GetProjectPathStringWithSlash() + "Scenes/" + "Game Levels/Master Scene/Master Scene.unity";
EditorBuildSettingsScene masterScene = new EditorBuildSettingsScene(masterscenePath, true);
if (buildScenes.Count > 0)
{
bool masterSceneNotFoundInBuild = false;
for (int i = 0; i < buildScenes.Count; i++)
{
if (buildScenes[i].path == masterScene.path)
{
masterSceneNotFoundInBuild = true;
break;
}
}
if (masterSceneNotFoundInBuild == false)
{
buildScenes.Add(masterScene);
}
}
else
{
buildScenes.Add(masterScene);
}
EditorBuildSettings.scenes = buildScenes.ToArray();
}
private void AddScene()
{
if (HasSceneName() == true)
{
Debug.LogError("Scene Name Is Required");
return;
}
GameLevelToolkitWindow toolkit = GameLevelToolkitWindow.GetRefreshedToolkitWindow();
string targetSceneFolderPath = GameLevelToolkitWindow.GetProjectPathStringWithSlash();
//Check If scene Already Exists
string targetSceneFile = "Assets/" + targetSceneFolderPath + "Scenes/" + targetSceneFolderPath + SceneAndResourceFolderName.folderNameValue + "/" + selectedGameLevel.gameLevelName + "_" + sceneNameToCreate + ".unity";
if (System.IO.File.Exists(targetSceneFile))
{
Debug.LogError("Scene Already Exists");
return;
}
CreateScene.CreateEmptyScene(selectedGameLevel.gameLevelName + "_" + sceneNameToCreate, selectedGameLevel.gameLevelName);
selectedGameLevel.assignedScenes.Add(sceneNameToCreate);
EditorUtility.SetDirty(selectedGameLevel);
if (automaticallyAddSceneToBuild == true)
{
List <EditorBuildSettingsScene> editorBuildSettingsScenes = new List <EditorBuildSettingsScene>();
//Get The Existing Build List
foreach (EditorBuildSettingsScene item in EditorBuildSettings.scenes)
{
editorBuildSettingsScenes.Add(item);
}
EditorBuildSettingsScene editorScene = new EditorBuildSettingsScene(targetSceneFile, true);
if (editorBuildSettingsScenes.Count > 0)
{
bool masterSceneNotFoundInBuild = false;
for (int i = 0; i < editorBuildSettingsScenes.Count; i++)
{
if (editorBuildSettingsScenes[i].path == editorScene.path)
{
masterSceneNotFoundInBuild = true;
break;
}
}
if (masterSceneNotFoundInBuild == false)
{
editorBuildSettingsScenes.Add(editorScene);
}
}
EditorBuildSettings.scenes = editorBuildSettingsScenes.ToArray();
}
OpenGameLevel.OpenLevel(selectedGameLevel, true, false, true);
}
private void DuplicateLevel()
{
if (HasNewLocationNameAssigned() == true)
{
Debug.LogError("Has No New Location Name Assigned");
return;
}
if (gameLevelToCreateDuplicateOf == null)
{
Debug.LogError("Location Required to Duplicate");
return;
}
GameLevelToolkitWindow toolkit = GameLevelToolkitWindow.GetRefreshedToolkitWindow();
string projectPathName = GameLevelToolkitWindow.GetProjectPathStringWithSlash();
//Check if there is a location already existing with that name.
GameLevel existingGameLevel = (GameLevel)AssetDatabase.LoadAssetAtPath("Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + newGameLevelName + "/" + newGameLevelName + ".asset", typeof(GameLevel));
if (existingGameLevel != null)
{
Debug.LogError("Location With Same Name Already Exists");
return;
}
//Create the Location Resource
GameLevel gameLevelResource = GameLevelData.CreateInstance <GameLevel>();
AssetDatabase.CreateAsset(GameLevel.CreateInstance <GameLevel>(), "Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + "Existing " + SceneAndResourceFolderName.folderNameValue + "/" + newGameLevelName + ".asset");
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
GameLevel createdGameLevel = (GameLevel)AssetDatabase.LoadAssetAtPath("Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + "Existing " + SceneAndResourceFolderName.folderNameValue + "/" + newGameLevelName + ".asset", typeof(GameLevel));
createdGameLevel.gameLevelName = newGameLevelName;
createdGameLevel.assignedScenesDirectory = "Assets/" + projectPathName + "Scenes/" + SceneAndResourceFolderName.folderNameValue + "/" + newGameLevelName;
createdGameLevel.levelDependencies = gameLevelToCreateDuplicateOf.levelDependencies;
createdGameLevel.assignedScenes = gameLevelToCreateDuplicateOf.assignedScenes;
GameLevelToolkitWindow.GetGameLevelsData().gameLevelsCreatedByUser.Add(createdGameLevel);
//Create the Scene Directory
string scenesFolder = AssetDatabase.CreateFolder("Assets/" + projectPathName + "Scenes/" + SceneAndResourceFolderName.folderNameValue, newGameLevelName);
//Copy the Existing Scenes
for (int i = 0; i < gameLevelToCreateDuplicateOf.assignedScenes.Count; i++)
{
string sceneToCopy = gameLevelToCreateDuplicateOf.assignedScenesDirectory + "/" + gameLevelToCreateDuplicateOf.gameLevelName + "_" + gameLevelToCreateDuplicateOf.assignedScenes[i] + ".unity";
string destination = createdGameLevel.assignedScenesDirectory + "/" + newGameLevelName + "_" + gameLevelToCreateDuplicateOf.assignedScenes[i] + ".unity";
FileUtil.CopyFileOrDirectory(sceneToCopy, destination);
}
EditorUtility.SetDirty(createdGameLevel);
EditorUtility.SetDirty(toolkit.gameLevelsData);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
public static GameLevel ReturnLocationFromDirectory(string directory)
{
GameLevelToolkitWindow toolkit = GameLevelToolkitWindow.GetRefreshedToolkitWindow();
string projectPathName = GameLevelToolkitWindow.GetProjectPathStringWithSlash();
GameLevel existingGameLevel = (GameLevel)AssetDatabase.LoadAssetAtPath("Assets/" + projectPathName + "/Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + directory + "/" + directory + ".asset", typeof(GameLevel));
return(null);
}
public static string GetGameLevelAssetFileDirectory(GameLevel level)
{
GameLevelToolkitWindow toolkit = GameLevelToolkitWindow.GetRefreshedToolkitWindow();
string projectDirectory = GameLevelToolkitWindow.GetProjectPathStringWithSlash();
string gameLevelDirectory = "Assets/" + projectDirectory + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + "Existing " + SceneAndResourceFolderName.folderNameValue + "/" + level.name + ".asset";
return(gameLevelDirectory);
}
private void FilterPotentialLevels()
{
List <EditorBuildSettingsScene> editorBuildSettingsScenes = BuildSettingsSceneManagement.GetEditorBuildSettingsScenes();
List <GameLevel> filteredGameLevelsList = new List <GameLevel>();
foreach (GameLevel item in targetLevels)
{
//Get Scene and Scene Path
bool doesAllScenesExistInBuild = false;
for (int i = 0; i < item.assignedScenes.Count; i++)
{
bool sceneExistsInBuild = false;
string gameLevelName = item.gameLevelName;
string scenePath = "Assets/" + GameLevelToolkitWindow.GetProjectPathStringWithSlash() + "Scenes/Game Levels/" + gameLevelName + "/" + gameLevelName + "_" + item.assignedScenes[i] + ".unity";
EditorBuildSettingsScene targetScene = new EditorBuildSettingsScene(scenePath, true);
for (int r = 0; r < editorBuildSettingsScenes.Count; r++)
{
if (editorBuildSettingsScenes[r].path == targetScene.path)
{
sceneExistsInBuild = true;
break;
}
}
if (sceneExistsInBuild == false)
{
doesAllScenesExistInBuild = false;
break;
}
else
{
doesAllScenesExistInBuild = true;
}
}
if (doesAllScenesExistInBuild == false)
{
filteredGameLevelsList.Add(item);
}
}
targetLevels = filteredGameLevelsList.ToArray();
List <string> levelsToString = new List <string>();
foreach (GameLevel item in targetLevels)
{
levelsToString.Add(item.gameLevelName);
}
targetLevelOptions = levelsToString.ToArray();
}
public static string GetProjectPathStringWithSlash()
{
GameLevelToolkitWindow toolkit = GameLevelToolkitWindow.GetRefreshedToolkitWindow();
string pathName = "";
if (toolkit.settings.useRootProjectDirectoryPath == false)
{
pathName = toolkit.settings.projectDirectoryPathName + "/";
}
return(pathName);
}
public static void RefreshLevelsList(out string[] levelOptionsToLoad, out int selectedValue, out GameLevel[] levels, out GameLevelData gameLevelData)
{
gameLevelData = GameLevelToolkitWindow.GetGameLevelsData();
selectedValue = 0;
levels = gameLevelData.gameLevelsCreatedByUser.ToArray();
List <string> levelsToString = new List <string>();
foreach (GameLevel item in levels)
{
levelsToString.Add(item.gameLevelName);
}
levelOptionsToLoad = levelsToString.ToArray();
}
public static string GetGameLevelResourceFolder(string locationName, bool includeSlashEnding = false)
{
GameLevelToolkitWindow toolkit = GameLevelToolkitWindow.GetRefreshedToolkitWindow();
string projectDirectory = GameLevelToolkitWindow.GetProjectPathStringWithSlash();
string targetDirectory = "Assets/" + projectDirectory + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + locationName;
if (includeSlashEnding == true)
{
targetDirectory += "/";
}
return(targetDirectory);
}
public static GameLevel ReturnGameLevel(string locationName)
{
GameLevelToolkitWindow toolkit = GameLevelToolkitWindow.GetRefreshedToolkitWindow();
string projectPathName = GameLevelToolkitWindow.GetProjectPathStringWithSlash();
GameLevel existingGameLevel = (GameLevel)AssetDatabase.LoadAssetAtPath("Assets/" + projectPathName + "/Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + locationName + "/" + locationName + ".asset", typeof(GameLevel));
if (existingGameLevel != null)
{
Debug.LogError("Location With Same Name Already Exists");
return(existingGameLevel);
}
return(null);
}
public static void OpenMenu()
{
window = (OpenGameLevel)GetWindow(typeof(OpenGameLevel), false, "Load Game Level");
window.gameLevelData = GameLevelToolkitWindow.GetGameLevelsData();
window.selectedValue = 0;
window.levels = window.gameLevelData.gameLevelsCreatedByUser.ToArray();
List <string> levelsToString = new List <string>();
foreach (GameLevel item in window.levels)
{
levelsToString.Add(item.gameLevelName);
}
window.levelOptionsToLoad = levelsToString.ToArray();
}
public static void OpenMenu()
{
window = GetWindow <AssignCategoryToLevel>("Assign Category To Level");
window.gameLevelData = GameLevelToolkitWindow.GetGameLevelsData();
window.selectedValue = 0;
window.levels = window.gameLevelData.gameLevelsCreatedByUser.ToArray();
List <string> levelsToString = new List <string>();
foreach (GameLevel item in window.levels)
{
levelsToString.Add(item.gameLevelName);
}
window.levelOptionsToLoad = levelsToString.ToArray();
}
private static string RemoveUneccessaryCharactersFromAssetPath(string originalPath)
{
GameLevelToolkitWindow toolkit = toolkitWindow;
int amountOfCharsToRemoveFromStart = 7;
if (toolkit.useRootProjectDirectoryPath == false)
{
amountOfCharsToRemoveFromStart += toolkit.projectDirectoryPathName.Length + 1;
}
amountOfCharsToRemoveFromStart += 10; //Remove the Resources Folder Directory
string pathAfterStartRemoved = originalPath.Remove(0, amountOfCharsToRemoveFromStart); //Remove the Assets/ + Any Projet Directory Path
string finalPath = pathAfterStartRemoved.Remove(pathAfterStartRemoved.Length - 6); //Remove the .Asset ending
return(finalPath);
}
public static void RenameCategory(string categoryOriginalName, string targetCategoryName)
{
//Get All Levels that Have this category and rename it there too
GameLevel[] levels = GetGameLevelsBasedOnCategory(categoryOriginalName);
RenameGameLevelsCategory(levels, targetCategoryName);
GameLevelData data = GameLevelToolkitWindow.GetGameLevelsData();
for (int i = 0; i < data.allUserCreatedCategories.Count; i++)
{
if (data.allUserCreatedCategories[i] == categoryOriginalName)
{
data.allUserCreatedCategories[i] = targetCategoryName;
break;
}
}
EditorUtility.SetDirty(data);
}
public static void DeleteExistingCategory(string targetCategory)
{
GameLevelData data = GameLevelToolkitWindow.GetGameLevelsData();
//Get All Levels that have this category and assign them to unassigned
GameLevel[] levels = GetGameLevelsBasedOnCategory(targetCategory);
RenameGameLevelsCategory(levels, data.unassignedCategoryName);
//Remove The Item From The data list
for (int i = 0; i < data.allUserCreatedCategories.Count; i++)
{
if (data.allUserCreatedCategories[i] == targetCategory)
{
data.allUserCreatedCategories.RemoveAt(i);
break;
}
}
EditorUtility.SetDirty(data);
}
public void OpenMasterScene()
{
List <Scene> loadedScenes = new List <Scene>();
for (int i = 0; i < SceneManager.sceneCount; i++)
{
loadedScenes.Add(SceneManager.GetSceneAt(i));
}
Scene[] loadedScenesArray = loadedScenes.ToArray();
EditorSceneManager.SaveModifiedScenesIfUserWantsTo(loadedScenesArray);
string scenePath = "Assets/" + GameLevelToolkitWindow.GetProjectPathStringWithSlash() + "Scenes/" + SceneAndResourceFolderName.folderNameValue + "/Master Scene/Master Scene.unity";
if (openAdditively == true)
{
EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Additive);
}
else
{
EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Single);
}
}
public static string[] GetAllCategories(bool includeAllType, bool includeUnassigned = true)
{
GameLevelData data = GameLevelToolkitWindow.GetGameLevelsData();
List <string> categories = new List <string>();
if (includeAllType == true)
{
categories.Add(data.allCategoriesName);
}
if (includeUnassigned == true)
{
categories.Add(data.unassignedCategoryName);
}
if (data.allUserCreatedCategories.Count > 0)
{
for (int i = 0; i < data.allUserCreatedCategories.Count; i++)
{
categories.Add(data.allUserCreatedCategories[i]);
}
}
return(categories.ToArray());
}
private void Uninstall()
{
string resourcesFolderDir = "Assets/" + GameLevelToolkitWindow.GetProjectPathStringWithSlash() + "Resources/" + SceneAndResourceFolderName.folderNameValue;
string scenesFolderDir = "Assets/" + GameLevelToolkitWindow.GetProjectPathStringWithSlash() + "Scenes/" + SceneAndResourceFolderName.folderNameValue;
//Destroy Resources
FileUtil.DeleteFileOrDirectory(resourcesFolderDir);
FileUtil.DeleteFileOrDirectory(resourcesFolderDir + ".meta");
//Destroy Created Scenes Folder
FileUtil.DeleteFileOrDirectory(scenesFolderDir);
FileUtil.DeleteFileOrDirectory(scenesFolderDir + ".meta");
if (GameLevelToolkitWindow.toolkitWindow != null)
{
GameLevelToolkitWindow.toolkitWindow.initialDataHasBeenCreated = false;
}
AssetDatabase.Refresh();
Debug.Log("Successful Uninstall");
}
public static void AddLevelToBuild(GameLevel level, List <EditorBuildSettingsScene> buildScenes = null, bool updateSceneBuild = true)
{
if (buildScenes == null)
{
buildScenes = GetEditorBuildSettingsScenes();
}
//Add Game Level
for (int i = 0; i < level.assignedScenes.Count; i++)
{
bool sceneExistsInBuild = false;
string scenePath = "Assets/" + GameLevelToolkitWindow.GetProjectPathStringWithSlash() + "Scenes/Game Levels/" + level.gameLevelName + "/" + level.gameLevelName + "_" + level.assignedScenes[i] + ".unity";
EditorBuildSettingsScene scene = new EditorBuildSettingsScene(scenePath, true);
for (int g = 0; g < buildScenes.Count; g++)
{
if (buildScenes[g].path == scene.path)
{
sceneExistsInBuild = true;
break;
}
}
if (sceneExistsInBuild == false)
{
buildScenes.Add(scene);
}
}
//Add Dependencies
for (int i = 0; i < level.levelDependencies.Count; i++)
{
for (int g = 0; g < level.levelDependencies[i].assignedScenes.Count; g++)
{
bool sceneExistsInBuild = false;
string gameLevelName = level.levelDependencies[i].gameLevelName;
string scenePath = "Assets/" + GameLevelToolkitWindow.GetProjectPathStringWithSlash() + "Scenes/Game Levels/" + gameLevelName + "/" + gameLevelName + "_" + level.levelDependencies[i].assignedScenes[g] + ".unity";
EditorBuildSettingsScene targetScene = new EditorBuildSettingsScene(scenePath, true);
for (int f = 0; f < buildScenes.Count; f++)
{
if (buildScenes[f].path == targetScene.path)
{
sceneExistsInBuild = true;
break;
}
}
if (sceneExistsInBuild == false)
{
buildScenes.Add(targetScene);
}
}
}
//Add Dependencies of Dependencies
for (int i = 0; i < level.levelDependencies.Count; i++)
{
for (int g = 0; g < level.levelDependencies[i].levelDependencies.Count; g++)
{
GameLevel targetDependency = level.levelDependencies[i].levelDependencies[g];
for (int f = 0; f < targetDependency.assignedScenes.Count; f++)
{
bool sceneExistsInBuild = false;
string gameLevelName = targetDependency.gameLevelName;
string scenePath = "Assets/" + GameLevelToolkitWindow.GetProjectPathStringWithSlash() + "Scenes/Game Levels/" + gameLevelName + "/" + gameLevelName + "_" + targetDependency.assignedScenes[f] + ".unity";
EditorBuildSettingsScene targetScene = new EditorBuildSettingsScene(scenePath, true);
for (int r = 0; r < buildScenes.Count; r++)
{
if (buildScenes[r].path == targetScene.path)
{
sceneExistsInBuild = true;
break;
}
}
if (sceneExistsInBuild == false)
{
buildScenes.Add(targetScene);
}
}
}
}
if (updateSceneBuild == true)
{
EditorBuildSettings.scenes = buildScenes.ToArray();
}
}
public static void OpenMenu()
{
window = (CreateNewGameLevelMenu)GetWindow(typeof(CreateNewGameLevelMenu), false, "Create New Level");
window.gameLevelData = GameLevelToolkitWindow.GetGameLevelsData();
}
private void CreateLevel()
{
GameLevelToolkitWindow toolkit = GameLevelToolkitWindow.GetRefreshedToolkitWindow();
string projectPathName = GameLevelToolkitWindow.GetProjectPathStringWithSlash();
//Check If the Location Already Exists
GameLevel existingLocation = (GameLevel)AssetDatabase.LoadAssetAtPath("Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + gameLevelName + "/" + gameLevelName + ".asset", typeof(GameLevel));
if (existingLocation != null)
{
Debug.LogError("Level With Same Name Already Exists");
return;
}
//First We Will need to make sure we have all the required data before proceeding
if (gameLevelName == null || gameLevelName == "")
{
Debug.LogError("Level Name Cannot Be Empty");
return;
}
//Check If Any Scene Names are empty
for (int i = 0; i < scenesToCreateInGameLevel.Count; i++)
{
if (scenesToCreateInGameLevel[i].VerifySceneNameIsNotEmpty() == true)
{
Debug.LogError("Scene Name Cannot Be Empty");
return;
}
}
for (int i = 0; i < scenesToCreateInGameLevel.Count; i++)
{
string sceneDirectory = gameLevelName;
CreateScene.CreateEmptyScene(gameLevelName + "_" + scenesToCreateInGameLevel[i].sceneName, sceneDirectory);
}
//Create the Location Resources
string resourceFolder = AssetDatabase.CreateFolder("Assets/" + projectPathName + "Resources/Locations", gameLevelName);
string newFolderPath = AssetDatabase.GUIDToAssetPath(resourceFolder);
//Check Does FolderExist To Place Resource File Inside
if (!Directory.Exists("Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/Existing " + SceneAndResourceFolderName.folderNameValue))
{
AssetDatabase.CreateFolder("Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue, "Existing " + SceneAndResourceFolderName.folderNameValue);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
GameLevel gameLevelResource = GameLevelData.CreateInstance <GameLevel>();
AssetDatabase.CreateAsset(GameLevel.CreateInstance <GameLevel>(), "Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/Existing " + SceneAndResourceFolderName.folderNameValue + "/" + gameLevelName + ".asset");
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
GameLevel createdGameLevel = (GameLevel)AssetDatabase.LoadAssetAtPath("Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/Existing " + SceneAndResourceFolderName.folderNameValue + "/" + gameLevelName + ".asset", typeof(GameLevel));
createdGameLevel.gameLevelName = gameLevelName;
createdGameLevel.assignedScenesDirectory = "Assets/" + projectPathName + "Scenes/" + SceneAndResourceFolderName.folderNameValue + "/" + gameLevelName;
createdGameLevel.assignedCategory = categories[selectedCategoryValue];
GameLevelToolkitWindow.GetGameLevelsData().gameLevelsCreatedByUser.Add(createdGameLevel);
EditorUtility.SetDirty(createdGameLevel);
for (int i = 0; i < scenesToCreateInGameLevel.Count; i++)
{
createdGameLevel.assignedScenes.Add(scenesToCreateInGameLevel[i].sceneName);
}
for (int i = 0; i < gameLevelDependencies.Count; i++)
{
createdGameLevel.levelDependencies.Add(gameLevelDependencies[i]);
}
EditorUtility.SetDirty(toolkit.gameLevelsData);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
OpenGameLevel.OpenLevel(createdGameLevel, true, false, true);
if (addLevelToUnityBuildScenes == true)
{
BuildSettingsSceneManagement.AddLevelToBuild(createdGameLevel);
}
}
private void CreateRequiredInitialData()
{
string projectPathName = "";
string projectPathNameWithoutSlash = "";
GameLevelToolkitWindow toolkit = GetRefreshedToolkitWindow();
if (toolkit.useRootProjectDirectoryPath == false)
{
projectPathName = toolkit.projectDirectoryPathName + "/";
projectPathNameWithoutSlash = toolkit.projectDirectoryPathName;
}
if (!Directory.Exists("Assets/" + projectPathName + "Resources"))
{
if (useRootProjectDirectoryPath == true)
{
string resourcesDirectory = AssetDatabase.CreateFolder("Assets", "Resources");
}
else
{
string resourcesDirectory = AssetDatabase.CreateFolder("Assets/" + projectPathNameWithoutSlash, "Resources");
}
}
if (!Directory.Exists("Assets/" + projectPathName + "Scenes"))
{
if (useRootProjectDirectoryPath == true)
{
string resourcesDirectory = AssetDatabase.CreateFolder("Assets", "Scenes");
}
else
{
string resourcesDirectory = AssetDatabase.CreateFolder("Assets/" + projectPathNameWithoutSlash, "Scenes");
}
}
if (!Directory.Exists("Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue))
{
//Create locationsResourceDirectory Directory
string gameLevelsResourceDirectoryGuid = AssetDatabase.CreateFolder("Assets/" + projectPathName + "Resources", SceneAndResourceFolderName.folderNameValue);
string gameLevelsResourceDirectoryPath = AssetDatabase.GUIDToAssetPath(gameLevelsResourceDirectoryGuid);
}
if (!Directory.Exists("Assets/" + projectPathName + "Scenes/" + SceneAndResourceFolderName.folderNameValue))
{
//Create Locations Directory in Scenes
string gameLevelsScenesDirectory = AssetDatabase.CreateFolder("Assets/" + projectPathName + "Scenes", SceneAndResourceFolderName.folderNameValue);
}
//Create Game Levels Data
string desiredGameLevelsDataDirectory = "Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + SceneAndResourceFolderName.folderNameValue + " Data.asset";
if (!Directory.Exists(desiredGameLevelsDataDirectory))
{
AssetDatabase.CreateAsset(GameLevelData.CreateInstance <GameLevelData>(), desiredGameLevelsDataDirectory);
}
//Create Game Levels Settings
string desiredGameLevelsSettingsDirectory = "Assets/" + projectPathName + "Resources/" + SceneAndResourceFolderName.folderNameValue + "/" + SceneAndResourceFolderName.folderNameValue + " Settings.asset";
if (!Directory.Exists(desiredGameLevelsSettingsDirectory))
{
AssetDatabase.CreateAsset(CreateInstance <GameLevelToolkitSettings>(), desiredGameLevelsSettingsDirectory);
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
toolkit.gameLevelsData = Resources.Load(SceneAndResourceFolderName.folderNameValue + "/" + SceneAndResourceFolderName.folderNameValue + " Data") as GameLevelData;
toolkit.settings = Resources.Load(SceneAndResourceFolderName.folderNameValue + "/" + SceneAndResourceFolderName.folderNameValue + " Settings") as GameLevelToolkitSettings;
toolkit.settings.useRootProjectDirectoryPath = toolkit.useRootProjectDirectoryPath;
toolkit.settings.projectDirectoryPathName = toolkit.projectDirectoryPathName;
//Create Master Scene
if (!Directory.Exists("Assets/" + projectPathName + "Scenes/" + SceneAndResourceFolderName.folderNameValue + "/MasterScene"))
{
//Create Master Scene Directory
string dir = AssetDatabase.CreateFolder("Assets/" + projectPathName + "Scenes/" + SceneAndResourceFolderName.folderNameValue, "Master Scene");
Scene masterScene = CreateScene.CreateEmptyScene("Master Scene", "Master Scene");
EditorSceneManager.OpenScene("Assets/" + projectPathName + "Scenes/" + SceneAndResourceFolderName.folderNameValue + "/Master Scene/Master Scene.unity");
}
EditorUtility.SetDirty(toolkit.settings);
EditorUtility.SetDirty(toolkit.gameLevelsData);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
EditorSceneManager.MarkAllScenesDirty();
//Setup Master Scene
Scene currentScene = SceneManager.GetActiveScene();
// GameObject geo = new GameObject();
GameObject go = new GameObject("Game Level Manager");
go.AddComponent <GameLevelManager>();
EditorSceneManager.SaveOpenScenes();
BuildSettingsSceneManagement.AddMasterSceneToBuild();
initialDataHasBeenCreated = true;
}
private static void OpenToolkitWindow()
{
toolkitWindow = GetRefreshedToolkitWindow();
OnEditorQuit();
}
private void MoveDirectory()
{
if (targetDirectoryToMoveToo == null || targetDirectoryToMoveToo == "")
{
Debug.LogError("Directory cannot be empty");
return;
}
GameLevelToolkitWindow toolkit = GameLevelToolkitWindow.GetRefreshedToolkitWindow();
string targetDirectory = "";
bool useRootDirectory = false;
if (targetDirectoryToMoveToo == "ROOT" || targetDirectory == "root")
{
targetDirectory = "";
useRootDirectory = true;
}
else
{
targetDirectory = targetDirectoryToMoveToo;
}
// Create Project Directory if Does Not Exist
if (useRootDirectory == false)
{
if (!Directory.Exists("Assets/" + targetDirectory))
{
//Create
AssetDatabase.CreateFolder("Assets", targetDirectory);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
}
string finalPath = "Assets/" + targetDirectory;
//Create Scenes Directory Inside of project if does not exist
if (!Directory.Exists(finalPath + "/" + "Scenes"))
{
AssetDatabase.CreateFolder(finalPath, "Scenes");
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
string scenesFolderPath = finalPath + "/Scenes";
//Create Resources Directory Inside of project if does not exist.
if (!Directory.Exists(finalPath + "/" + "Resources"))
{
AssetDatabase.CreateFolder(finalPath, "Resources");
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
string resourcesFolderPath = finalPath + "/Resources";
//Move Resources Data
string originalResourcesDirectory = "";
if (toolkit.settings.useRootProjectDirectoryPath == false)
{
originalResourcesDirectory = "Assets/" + toolkit.settings.projectDirectoryPathName + "/Resources/" + SceneAndResourceFolderName.folderNameValue;
}
else
{
originalResourcesDirectory = "Assets/" + "Resources/" + SceneAndResourceFolderName.folderNameValue;
}
FileUtil.MoveFileOrDirectory(originalResourcesDirectory, resourcesFolderPath + "/" + SceneAndResourceFolderName.folderNameValue);
FileUtil.MoveFileOrDirectory(originalResourcesDirectory + ".meta", resourcesFolderPath + "/" + SceneAndResourceFolderName.folderNameValue + ".meta");
//Move Game Levels Scenes Directory
string originalScenesDirectory = "";
if (toolkit.settings.useRootProjectDirectoryPath == false)
{
originalScenesDirectory = "Assets/" + toolkit.settings.projectDirectoryPathName + "/Scenes/" + SceneAndResourceFolderName.folderNameValue;
}
else
{
originalScenesDirectory = "Assets/" + "Scenes/" + SceneAndResourceFolderName.folderNameValue;
}
FileUtil.MoveFileOrDirectory(originalScenesDirectory, scenesFolderPath + "/" + SceneAndResourceFolderName.folderNameValue);
FileUtil.MoveFileOrDirectory(originalScenesDirectory + ".meta", scenesFolderPath + "/" + SceneAndResourceFolderName.folderNameValue + ".meta");
//Update All Scenes Directory Paths in data
//Update the settings file with the new directory
if (useRootDirectory == true)
{
toolkit.settings.useRootProjectDirectoryPath = true;
toolkit.settings.projectDirectoryPathName = "";
}
else
{
toolkit.settings.useRootProjectDirectoryPath = false;
toolkit.settings.projectDirectoryPathName = targetDirectoryToMoveToo;
}
EditorUtility.SetDirty(toolkit.settings);
EditorUtility.SetDirty(toolkit.gameLevelsData);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
Debug.Log("Move Operation Completed Succesfully");
}
private void AddSceneToLocation()
{
string projectPathName = GameLevelToolkitWindow.GetProjectPathStringWithSlash();
if (targetGameLevel == null)
{
Debug.LogError("Target Location Is Required");
return;
}
string originalScenePath = null;
if (useRootDirectory == true)
{
originalScenePath = "Assets/" + targetSceneFolderPath + ".unity";
}
else
{
originalScenePath = "Assets/" + projectPathName + "Scenes/" + targetSceneFolderPath + "/" + targetSceneName + ".unity";
}
//Check to See If the scene belongs to an existing location
bool sceneExistsInAGameLevel = false;
string sceneNameWithoutGameLevelPrefix = null;
GameLevelData gameLevelData = GameLevelToolkitWindow.GetGameLevelsData();
for (int i = 0; i < gameLevelData.gameLevelsCreatedByUser.Count; i++)
{
for (int g = 0; g < gameLevelData.gameLevelsCreatedByUser[i].assignedScenes.Count; g++)
{
string assignedSceneName = gameLevelData.gameLevelsCreatedByUser[i].gameLevelName + "_" + gameLevelData.gameLevelsCreatedByUser[i].assignedScenes[g];
if (assignedSceneName == targetSceneName)
{
sceneNameWithoutGameLevelPrefix = gameLevelData.gameLevelsCreatedByUser[i].assignedScenes[g];
//Remove this scene from its location that it is apart of
gameLevelData.gameLevelsCreatedByUser[i].assignedScenes.Remove(targetSceneName);
sceneExistsInAGameLevel = true;
}
}
}
//Rename the scene based on the location naming convention
string targetGameLevelPrefix = targetGameLevel.gameLevelName;
string finalSceneName = null;
if (sceneExistsInAGameLevel == true)
{
finalSceneName = targetGameLevelPrefix + "_" + sceneNameWithoutGameLevelPrefix + ".unity";
targetGameLevel.assignedScenes.Add(finalSceneName);
}
else
{
finalSceneName = targetGameLevelPrefix + "_" + targetSceneName + ".unity";
targetGameLevel.assignedScenes.Add(targetSceneName);
}
AssetDatabase.RenameAsset(originalScenePath, finalSceneName);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
//Move the scene to the correct Directory
string adjustedDirectoryToMoveSceneFrom = "Assets/" + projectPathName + targetSceneFolderPath + "/" + targetSceneName + ".unity";
string directoryToMoveSceneTo = targetGameLevel.assignedScenesDirectory + "/" + finalSceneName;
FileUtil.MoveFileOrDirectory(adjustedDirectoryToMoveSceneFrom, directoryToMoveSceneTo);
EditorUtility.SetDirty(targetGameLevel);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
public static void OpenLevel(GameLevel targetGameLevel, bool includeMasterScene, bool keepCurrentScenesThatAreOpenOpeneded, bool includeDependencies)
{
List <Scene> loadedScenes = new List <Scene>();
for (int i = 0; i < SceneManager.sceneCount; i++)
{
loadedScenes.Add(SceneManager.GetSceneAt(i));
}
Scene[] loadedScenesArray = loadedScenes.ToArray();
EditorSceneManager.SaveModifiedScenesIfUserWantsTo(loadedScenesArray);
//Load The Master Scene
if (includeMasterScene == true)
{
string masterScenePath = "Assets/" + GameLevelToolkitWindow.GetProjectPathStringWithSlash() + "Scenes/" + SceneAndResourceFolderName.folderNameValue + "/Master Scene/Master Scene.unity";
Scene masterScene;
if (keepCurrentScenesThatAreOpenOpeneded == true)
{
masterScene = EditorSceneManager.OpenScene(masterScenePath, OpenSceneMode.Additive);
}
else
{
masterScene = EditorSceneManager.OpenScene(masterScenePath, OpenSceneMode.Single);
}
EditorSceneManager.SetActiveScene(masterScene);
}
//Unload Any Existing Scenes If Required
if (includeMasterScene == false && keepCurrentScenesThatAreOpenOpeneded == false)
{
for (int i = 0; i < SceneManager.sceneCount; i++)
{
Scene scene = SceneManager.GetSceneAt(i);
if (!IsActiveScene(scene))
{
CloseScene(scene);
}
if (scene.name == "Master Scene")
{
if (!IsActiveScene(scene))
{
EditorSceneManager.SetActiveScene(scene);
}
}
}
}
//Load The Locations Scenes
LoadLocationsScenesAdditively(targetGameLevel);
//Load Dependencies If Required
if (includeDependencies == true)
{
for (int i = 0; i < targetGameLevel.levelDependencies.Count; i++)
{
LoadLocationsScenesAdditively(targetGameLevel.levelDependencies[i]);
}
}
}
