async public Task GitCommitChangesToRepo(List <Object> selectedBundleIN, string gitCommitM)
{
AssetDatabase.SaveAssets();//saves assets so all meta files show up
List <string> commands = new List <string>();
List <string> filesToAdd = new List <string>();
filesToAdd.AddRange(IFXToolSM.GetFolderDependencies(selectedBundleIN));
commands.Add("cd /D " + "\"" + userSettings.projectWinLoc + "\"");
commands.Add("git stash");
commands.Add("git pull");
commands.Add("git stash pop");
commands.Add("git reset");
foreach (var item in filesToAdd)
{
commands.Add("git add " + "\"" + userSettings.projectWinLoc + "/" + item + "\"");
commands.Add("git add " + "\"" + userSettings.projectWinLoc + "/" + item + ".meta" + "\"");
}
commands.Add("git status");
commands.Add("git commit -m " + "\"" + gitCommitM + "\"");
commands.Add("git push");
commands.Add("PAUSE");
foreach (var item in commands)
{
Debug.Log(item);
}
string gitCommitBatch = IFXToolSM.CreateBatchCMDSFile("GitCommitToRepo", commands);
var gitAddResults = RunBatchFileAsync(gitCommitBatch);
var results = await Task.WhenAll(gitAddResults);
System.IO.File.WriteAllText(userSettings.projectWinLoc + "/Git changes push Debug Log.txt", results[0]);
}
public List <string> CreateiOSBatchFile(BundleBuildSettings buildSettings, string cdnLocalLoc)
{
List <string> commands = new List <string>();
foreach (var command in IFXToolSM.RoboCopyDependenciesFiles("iOS", userSettings.projectWinLoc, buildSettings.selectedBundles))
{
commands.Add(command);
}
string batchmode = "-batchmode";
if (userSettings.debugMode == true)
{
batchmode = "";
}
commands.Add("\"" + userSettings.unityEXELoc + "\" -quit " + batchmode + " -buildTarget \"iOS\" -projectPath \"" + userSettings.projectiOSLoc + "\" -executeMethod AssetBundles.BuildScript.BuildAssetBundles");
commands.Add("robocopy " + "\"" + userSettings.projectWinLoc + "/IFXBuildToolProjects/iOS/AssetBundles/iOS" + "\"" + " " + "\"" + userSettings.projectWinLoc + "/AssetBundles/iOS" + "\"");
if (cdnLocalLoc != null)
{
if (userSettings.cdnAndroidIFXLoc != "" && userSettings.CTMode())
{
commands.Add("robocopy " + "\"" + userSettings.projectiOSLoc + "/AssetBundles/iOS" + "\"" + " " + "\"" + cdnLocalLoc + "\"");
}
}
if (userSettings.debugMode == true)
{
commands.Add("PAUSE");
}
return(commands);
}
void EmptyPrefabWindowUI()
{
EditorGUILayout.LabelField("Add a top level zeroed out empty", EditorStyles.boldLabel);
if (GUILayout.Button("Create zeroed prefab"))
{
IFXToolSM.InsertSelectedObjectIntoEmpty(Selection.gameObjects, userSettings.prefabPrefix, userSettings.prefabAfix);
}
}
void AnimCNTRLFromClipsWindowUI()
{
QuickToolsHelp.AnimClipsFromFBXInstructions(); // displays the instructions for this tool
if (GUILayout.Button("Quick Create Anim Controlers"))
{
IFXToolSM.CreateAnimClipsFromSelectedFBX();
}
}
void CreateImagePlaneUI()
{
EditorGUILayout.LabelField("Create Image Plane From image", EditorStyles.boldLabel);
EditorGUILayout.LabelField("This feature still needs error handeling to be written");
if (GUILayout.Button("Image plane from Image"))
{
IFXToolSM.ImagePlaneFromImage();
}
}
void NewDependenciesWindowUI()
{
// Create all the folders and stuff for a new dependencie
QuickToolsHelp.NewDependenciesWindowInstructions(); // displays the instructions for this tool
folderName = EditorGUILayout.TextField("Folder Name: ", folderName);
if (GUILayout.Button("Create Folders"))
{
IFXToolSM.CreateDependenciesFolder(userSettings.currentIFXNum, folderName);
}
}
void IFXToolsQualityCheckToolUI()
{
Rect groupRect = new Rect(5, 25, Screen.width - 20, Screen.height - 10);
scrollPos = EditorGUILayout.BeginScrollView(scrollPos, GUILayout.Width(groupRect.width), GUILayout.Height(groupRect.height - 175));
foreach (QACheckListItem item in checkList)
{
GUILayout.BeginVertical(EditorStyles.helpBox);
EditorGUILayout.LabelField("Name: " + item.rootGameObject.name, EditorStyles.boldLabel);
foreach (string error in item.errors)
{
GUILayout.Label("Errors: " + error);
}
if (GUILayout.Button("open prefab"))
{
AssetDatabase.OpenAsset(item.rootGameObject);
this.Close();
}
if (GUILayout.Button("Auto Fix prefab"))
{
IFXToolSM.FixPrefabs(item.rootGameObject);
}
GUILayout.EndVertical();
GUILayout.Label(" ");
}
GUILayout.Label(" ");
GUILayout.Label(" ");
EditorGUILayout.EndScrollView();
if (GUI.Button(new Rect(10, groupRect.height - 175, groupRect.width, 50), "Recheck Bundle"))
{
BundleQualityCheck(buildSettingsStored);
}
if (GUI.Button(new Rect(10, groupRect.height - 125, groupRect.width, 50), "Ignore Remaining Issues"))
{
buildSettingsStored.buildQACheckOverride = true;
bundleTool.BuildSelectedBundle(buildSettingsStored);
this.Close();
}
if (GUI.Button(new Rect(10, groupRect.height - 75, groupRect.width, 50), "Cancel"))
{
this.Close();
}
}
public bool BundleQualityCheck(BundleBuildSettings buildSettings)// Also clears asset labels from prefabs while it's at it.
{
buildSettingsStored = buildSettings;
bool QualityCheck = true;
checkList.Clear();
foreach (UnityEngine.Object item in buildSettings.selectedBundles)
{
string path = AssetDatabase.GetAssetPath(item);
DirectoryInfo dirInfo = new DirectoryInfo(path);
FileInfo[] fileInf = dirInfo.GetFiles("*.prefab");
//loop through directory loading the game object and checking if it has the component you want
if (fileInf != null)
{
foreach (FileInfo file in fileInf)
{
string fullPath = file.FullName.Replace(@"\", "/");
string assetPath = "Assets" + fullPath.Replace(Application.dataPath, "");
GameObject prefab = AssetDatabase.LoadAssetAtPath(assetPath, typeof(GameObject)) as GameObject;
if (prefab != null)
{
List <string> errors = IFXToolSM.PrefabQualityCheck(prefab);
if (errors.Count > 0)
{
checkList.Add(new QACheckListItem(prefab, errors));
QualityCheck = false;
OpenQAErrorWindow();
}
}
}
}
else
{
Debug.Log("Failed to find prefabs in bundle");
}
}
return(QualityCheck);
}
void AutoPivotUI()
{
QuickToolsHelp.AutoPivotInstructions(); // displays the instructions for this tool
altCenterMethod = GUILayout.Toggle(altCenterMethod, "ALT Centering");
if (GUILayout.Button("Auto Pivot"))
{
if (Selection.gameObjects != null)
{
//string assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(Selection.gameObjects[0]);
//string assetPath = AssetDatabase.GetAssetPath(Selection.gameObjects[0]);
//Debug.Log("Asset path is: "+assetPath);
IFXToolSM.BatchCenterIFX(Selection.gameObjects, false);
}
else
{
Debug.Log("Nothing selected - please select the top most object of the hierarchy and try again");
}
}
}
void SettingsWindowUI()
{
EditorGUILayout.LabelField("");//blank space for formating
// If this is toggled delete the entire project folders in the cache when clear button hit
hardResetCache = EditorGUILayout.Toggle("Full Reset Cache", hardResetCache);
//delete the asset folders in the build projects
if (GUILayout.Button("Clear Build Projects Cache"))
{
IFXToolSM.ClearDependenciesCache(hardResetCache, userSettings.projectWinLoc);
}
if (GUILayout.Button("Test Button"))
{
var alldascripts = IFXToolSM.GetAllScriptsInProject();
foreach (var item in alldascripts)
{
Debug.Log(item.ToString());
}
}
EditorGUILayout.LabelField("");//blank space for formating
//ct mode only settings such as cdn
if (userSettings.CTMode())
{
userSettings.debugMode = EditorGUILayout.Toggle("Enable DebugMode", userSettings.debugMode);
EditorGUILayout.LabelField("Windows Project Folder: " + userSettings.projectWinLoc);
EditorGUILayout.LabelField("Android Project Folder: " + userSettings.projectAndroidLoc);
EditorGUILayout.LabelField("iOS Project Folder: " + userSettings.projectiOSLoc);
EditorGUILayout.LabelField("Set the paths to your CDN Project folder");
EditorGUILayout.LabelField("CDN Project Folder: " + userSettings.cdnProjectPath);
EditorGUILayout.LabelField("IFX CDN Win Project Folder: " + userSettings.cdnWinIFXLoc);
EditorGUILayout.LabelField("IFX CDN Android Project Folder: " + userSettings.cdnAndroidIFXLoc);
EditorGUILayout.LabelField("IFX CDN iOS Project Folder: " + userSettings.cdniOSIFXLoc);
EditorGUILayout.LabelField("Scene CDN Win Project Folder: " + userSettings.cdnWinSceneLoc);
EditorGUILayout.LabelField("Scene CDN Android Project Folder: " + userSettings.cdnAndroidSceneLoc);
EditorGUILayout.LabelField("Scene CDN iOS Project Folder: " + userSettings.cdniOSSceneLoc);
if (GUILayout.Button("CDN Project Folder - Browse"))
{
userSettings.cdnProjectPath = EditorUtility.OpenFolderPanel("Select Windows CDN folder", "", "");
userSettings.SettingsAutoSetup();
}
EditorGUILayout.LabelField("OPTIONAL settings below");
userSettings.prefabPrefix = EditorGUILayout.TextField("Prefix for creating prefabs ", userSettings.prefabPrefix);
userSettings.prefabAfix = EditorGUILayout.TextField("Afix for creating prefabs ", userSettings.prefabAfix);
EditorGUILayout.LabelField("");//blank space for formating
userSettings.currentIFXNum = EditorGUILayout.TextField("current ifx number:", userSettings.currentIFXNum);
EditorGUILayout.LabelField("");//blank space for formating
userSettings.thumbnailSavePath = EditorGUILayout.TextField("Thumbnail Save Location: ", userSettings.thumbnailSavePath);
if (GUILayout.Button("Select Thumbnail Save Location"))
{
userSettings.thumbnailSavePath = EditorUtility.OpenFolderPanel("Thumbnail Save Location", "", "");
}
}
EditorGUILayout.LabelField("");//blank space for formating
if (GUILayout.Button("Save Settings"))
{
userSettings.SaveUserSettings();
}
}
void BuildSelectedBundleWindowUI()
{
if (bundleTools.buildingStatus != null)
{
GUIStyle buildstatusStyle = new GUIStyle();
buildstatusStyle.fontSize = 45;
buildstatusStyle.normal.textColor = Color.red;
GUI.Label(new Rect(20, Screen.height / 2, 300, 50), bundleTools.buildingStatus, buildstatusStyle);
//EditorGUILayout.LabelField(bundleTools.buildingStatus);//Building Status.
}
QuickToolsHelp.BuildBundlesInstructions(); // displays the instructions for this tool
//with qa check disabled it will skip the whole qa process. sometimes qeird components or things like that can trip it up so I left the option to skip it.
buildQACheckOverride = EditorGUILayout.Toggle("Disable Quality Check", buildQACheckOverride);
//ct mode dsiables the git stuff
if (userSettings.CTMode())
{
autoGitYesNo = EditorGUILayout.Toggle("Push Bundles To CDN?", autoGitYesNo);
gitCommitM = EditorGUILayout.TextField("Git Commit message: ", gitCommitM);
if (GUILayout.Button("Push changes in folder to git"))
{
if (gitCommitM == "")
{
EditorUtility.DisplayDialog("WARNING!", "To auto push you need to enter a commit message", "OK", "Cancel");
}
else
{
bundleTools.GitCommitChangesToRepo(IFXToolSM.GetSelectedObjectsAsList(), gitCommitM);
}
}
}
windowsBuildYesNo = EditorGUILayout.Toggle("Build for Windows?", windowsBuildYesNo);
androidBuildYesNo = EditorGUILayout.Toggle("Build for Android?", androidBuildYesNo);
iOSBuildYesNo = EditorGUILayout.Toggle("Build for iOS?", iOSBuildYesNo);
//CheckList
QuickToolsHelp.PreBuildChecklist(); // displays the instructions for this tool
if (GUILayout.Button("AssetBundle From Selection"))
{
if (autoGitYesNo == true && gitCommitM == "")
{
EditorUtility.DisplayDialog("WARNING!", "To auto push you need to enter a commit message", "OK", "Cancel");
}
else if (IFXToolSM.SelectionIsDirectoryBool(Selection.objects) == false)
{
EditorUtility.DisplayDialog("WARNING!", "Please Only Have FOLDERS Selected", "OK", "Cancel");
}
else
{
List <Object> selectedBundles = new List <Object>();
foreach (var dir in Selection.objects)
{
//check if the bundles has scene files and if they are the only file type present
if (IFXToolSM.DoesSelectedFolderContainOnlyScenes(dir) == false && IFXToolSM.DoesSelectedFolderContainFileType(dir, "*.unity") == true)
{
EditorUtility.DisplayDialog("WARNING!", "When Building scenes please ensure ONLY scene files are in the selected folder", "OK", "Cancel");
return;
}
//add the bundle so long as the above dosn't trigger
selectedBundles.Add(dir);
}
BundleBuildSettings buildSettings = new BundleBuildSettings();
buildSettings.selectedBundles = selectedBundles;
buildSettings.windowsBuildYesNo = windowsBuildYesNo;
buildSettings.androidBuildYesNo = androidBuildYesNo;
buildSettings.iOSBuildYesNo = iOSBuildYesNo;
buildSettings.buildQACheckOverride = buildQACheckOverride;
buildSettings.autoGitYesNo = autoGitYesNo;
buildSettings.gitCommitMessage = gitCommitM;
// Build the bundles!
bundleTools.BuildSelectedBundle(buildSettings);
}
}
if (bundlesBuilding)
{
EditorGUILayout.LabelField("Building Bundles...", EditorStyles.boldLabel);
}
}
public void BuildSelectedBundle(BundleBuildSettings buildSettings)
{
//check for module folders
if (buildSettings.androidBuildYesNo)
{
if (IFXToolSM.CheckBuildModuleInstalled("AndroidPlayer") == false)
{
EditorUtility.DisplayDialog("WARNING!", "Android Build module not installed!", "OK");
return;
}
}
if (buildSettings.iOSBuildYesNo)
{
if (IFXToolSM.CheckBuildModuleInstalled("iOSSupport") == false)
{
EditorUtility.DisplayDialog("WARNING!", "iOS Build module not installed!", "OK");
return;
}
}
passedQualityCheck = true;
//local Cdn paths//To enable swaping from ifx to scenes
string cdnLocalWinLoc = userSettings.cdnWinIFXLoc;
string cdnLocalAndroidLoc = userSettings.cdnAndroidIFXLoc;
string cdnLocaliOSLoc = userSettings.cdniOSIFXLoc;
for (int i = 0; i < buildSettings.selectedBundles.Count; i++)
{
if (IFXToolSM.DoesSelectedFolderContainFileType(buildSettings.selectedBundles[i], "*.unity") == true)
{
cdnLocalWinLoc = userSettings.cdnWinSceneLoc;
cdnLocalAndroidLoc = userSettings.cdnAndroidSceneLoc;
cdnLocaliOSLoc = userSettings.cdniOSSceneLoc;
}
}
if (buildSettings.autoGitYesNo)
{
IFXToolSM.GitPull(userSettings.cdnProjectPath);
}
bundlesBuiltWin.Clear();
bundlesBuiltAndroid.Clear();
bundlesBuiltiOS.Clear();
/////////////////////////////////////////////////////////////^Set Up ^///////////////////////////
if (buildSettings.selectedBundles != null)
{
IFXToolSM.ClearAllAssetLabelsInProject();
for (int i = 0; i < buildSettings.selectedBundles.Count; i++)
{
//re add asset labels based on folders names to selected folders
SetAssetLabelToFolderName(buildSettings.selectedBundles[i]);
}
//Checks for bad components
if (!buildSettings.buildQACheckOverride)
{
qaTool = (IFXToolsQualityCheckTool)ScriptableObject.CreateInstance(typeof(IFXToolsQualityCheckTool));
qaTool.Init(this);
bool qaCheck = qaTool.BundleQualityCheck(buildSettings); //pass QA true or false
if (!qaCheck)
{
passedQualityCheck = false;
}
}
///////////////////////////////////////////////////////Passed QA Check - Build bundles////////////////////
if (passedQualityCheck | buildSettings.buildQACheckOverride)
{
buildSettings.buildQACheckOverride = false;
buildBundlesAsync();
}
}
else
{
Debug.Log("Nothing Selected - Select the folder you want built first");
}
///////////////////////////////////////////Local Methods/////////////////////////////////////////////////
void SetAssetLabelToFolderName(UnityEngine.Object item)
{
//This part changes the asset labelsS
var itemPath = AssetDatabase.GetAssetPath(item);
var itemDirectory = Path.GetDirectoryName(itemPath);
var itemFolderName = Path.GetFileName(itemPath);
AssetImporter assetImporterForSelection = AssetImporter.GetAtPath(itemPath);
assetImporterForSelection.assetBundleName = itemFolderName;
}
void SetUpGitPathsForCreatedFiles()
{
for (int i = 0; i < buildSettings.selectedBundles.Count; i++)
{
//Check if any of the selected folders have scenes.
bool isScene = IFXToolSM.DoesSelectedFolderContainFileType(buildSettings.selectedBundles[i], "*.unity");
if (isScene == true)
{
Debug.Log("scene found in bundle: " + buildSettings.selectedBundles[i].name);
if (buildSettings.androidBuildYesNo)
{
bundlesBuiltAndroid.Add(userSettings.cdnAndroidSceneLoc + "/" + buildSettings.selectedBundles[i].name + ".engagebundle");
bundlesBuiltAndroid.Add(userSettings.cdnAndroidSceneLoc + "/" + buildSettings.selectedBundles[i].name + ".manifest");
}
if (buildSettings.iOSBuildYesNo)
{
bundlesBuiltiOS.Add(userSettings.cdniOSSceneLoc + "/" + buildSettings.selectedBundles[i].name + ".engagebundle");
bundlesBuiltiOS.Add(userSettings.cdniOSSceneLoc + "/" + buildSettings.selectedBundles[i].name + ".manifest");
}
if (buildSettings.windowsBuildYesNo)
{
bundlesBuiltWin.Add(userSettings.cdnWinSceneLoc + "/" + buildSettings.selectedBundles[i].name + ".engagebundle");
bundlesBuiltWin.Add(userSettings.cdnWinSceneLoc + "/" + buildSettings.selectedBundles[i].name + ".manifest");
}
}
else
{
if (buildSettings.androidBuildYesNo)
{
bundlesBuiltAndroid.Add(userSettings.cdnAndroidIFXLoc + "/" + buildSettings.selectedBundles[i].name + ".engagebundle");
bundlesBuiltAndroid.Add(userSettings.cdnAndroidIFXLoc + "/" + buildSettings.selectedBundles[i].name + ".manifest");
}
if (buildSettings.iOSBuildYesNo)
{
bundlesBuiltiOS.Add(userSettings.cdniOSIFXLoc + "/" + buildSettings.selectedBundles[i].name + ".engagebundle");
bundlesBuiltiOS.Add(userSettings.cdniOSIFXLoc + "/" + buildSettings.selectedBundles[i].name + ".manifest");
}
if (buildSettings.windowsBuildYesNo)
{
bundlesBuiltWin.Add(userSettings.cdnWinIFXLoc + "/" + buildSettings.selectedBundles[i].name + ".engagebundle");
bundlesBuiltWin.Add(userSettings.cdnWinIFXLoc + "/" + buildSettings.selectedBundles[i].name + ".manifest");
}
}
}
}
void GitPushBundlesToCDN()
{
List <string> commands = new List <string>();
//string listOfBundles = string.Join(" ", bundlesBuiltWin);
commands.Add("cd /D " + "\"" + userSettings.cdnProjectPath + "\"");
foreach (var item in bundlesBuiltWin)
{
commands.Add("git add " + "\"" + item + "\"");
}
foreach (var item in bundlesBuiltAndroid)
{
commands.Add("git add " + "\"" + item + "\"");
}
foreach (var item in bundlesBuiltiOS)
{
commands.Add("git add " + "\"" + item + "\"");
}
commands.Add("git commit -m " + "\"" + buildSettings.gitCommitMessage + "\"");
commands.Add("git push");
IFXToolSM.RunCMD(commands);
}
async Task buildBundlesAsync()
{
SetUpGitPathsForCreatedFiles();
buildingStatus = "Building Bundles";
// if true build windows
if (buildSettings.windowsBuildYesNo)
{
IFXToolSM.DeleteFolderContents(userSettings.projectWinLoc + "/AssetBundles/Windows"); //clears out old bundles
//Build the bundle
AssetBundles.BuildScript.BuildAssetBundles();
//Copy bundles to cdn
if (!string.IsNullOrEmpty(cdnLocalWinLoc) && userSettings.CTMode())
{
IFXToolSM.CopyFolderContents(userSettings.projectWinLoc + "/AssetBundles/Windows", cdnLocalWinLoc);
}
}
List <Task <string> > BundleBuildTasks = new List <Task <string> >();
// if true build android
if (buildSettings.androidBuildYesNo)
{
IFXToolSM.DeleteFolderContents(userSettings.projectAndroidLoc + "/AssetBundles/Android"); //clears out old bundles
IFXToolSM.DeleteFolderContents(userSettings.projectWinLoc + "/AssetBundles/Android"); //clears out old bundles
string androidBuildPath = IFXToolSM.CreateBatchCMDSFile("Android", IFXToolSM.SyncUnityProjects("Android", userSettings.projectWinLoc), CreateAndroidBatchFile(buildSettings, cdnLocalAndroidLoc));
//RunBuildFileAsync(androidBuildPath, "Android");
BundleBuildTasks.Add(Task.Run(() => RunBatchFileAsync(androidBuildPath)));
//Debug.Log(androidBuild.Output);
}
// if true build iOS
if (buildSettings.iOSBuildYesNo)
{
IFXToolSM.DeleteFolderContents(userSettings.projectiOSLoc + "/AssetBundles/iOS"); //clears out old bundles
IFXToolSM.DeleteFolderContents(userSettings.projectWinLoc + "/AssetBundles/iOS"); //clears out old bundles
string iOSBuildPath = IFXToolSM.CreateBatchCMDSFile("iOS", IFXToolSM.SyncUnityProjects("iOS", userSettings.projectWinLoc), CreateiOSBatchFile(buildSettings, cdnLocaliOSLoc));
//RunBuildFileAsync(iOSBuildPath, "iOS");
BundleBuildTasks.Add(Task.Run(() => RunBatchFileAsync(iOSBuildPath)));
// Git stuff handled in batch file!
}
Debug.Log("Waiting for all build tasks to finish");
var results = await Task.WhenAll(BundleBuildTasks);
Debug.Log("all build tasks now finished");
/////////////////////////////CDN Push////////////////////////
buildingStatus = "Finished Building";
if (buildSettings.autoGitYesNo)
{
GitPushBundlesToCDN();
}
BuildDebugChecks(results);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void BuildDebugChecks(string[] buildLogsIN)
{
StringBuilder bundleBuildLogFull = new StringBuilder();
bundleBuildLogFull.Append(System.Environment.NewLine + " //////////////////////////////////////////USER SETTINGS///////////////////////////////////");
bundleBuildLogFull.Append(System.Environment.NewLine + userSettings.cdnProjectPath + " -CDN Project path");
bundleBuildLogFull.Append(System.Environment.NewLine + userSettings.cdnWinIFXLoc + " -CDN project path Windows");
bundleBuildLogFull.Append(System.Environment.NewLine + userSettings.cdnAndroidIFXLoc + " -CDN project path Android");
bundleBuildLogFull.Append(System.Environment.NewLine + userSettings.cdniOSIFXLoc + " -CDN project path iOS");
bundleBuildLogFull.Append(System.Environment.NewLine + userSettings.projectWinLoc + " -Project path Windows");
bundleBuildLogFull.Append(System.Environment.NewLine + userSettings.projectAndroidLoc + " -Project path Android");
bundleBuildLogFull.Append(System.Environment.NewLine + userSettings.projectiOSLoc + " -Project path iOS");
bundleBuildLogFull.Append(System.Environment.NewLine + userSettings.unityEXELoc + " -Unity EXE");
bundleBuildLogFull.Append(System.Environment.NewLine + userSettings.thumbnailSavePath + " -Thumbnail save Path");
bundleBuildLogFull.Append(System.Environment.NewLine + " //////////////////////////////////////////BUNDLES BUILT///////////////////////////////////");
bool windowsBuildSuccess = true;
bool androidBuildSuccess = true;
bool iOSBuildSuccess = true;
if (buildSettings.windowsBuildYesNo)
{
windowsBuildSuccess = false;
foreach (var item in bundlesBuiltWin)
{
//Debug.Log(item);
string fileName = Path.GetFileName(item);
string BundleBuiltPath = userSettings.projectWinLoc + "/AssetBundles/Windows/" + fileName;
Debug.Log(BundleBuiltPath);
if (File.Exists(BundleBuiltPath))
{
bundleBuildLogFull.Append(System.Environment.NewLine + BundleBuiltPath + " : Bundle Built successfully");
windowsBuildSuccess = true;
}
else
{
bundleBuildLogFull.Append(System.Environment.NewLine + BundleBuiltPath + " : Bundle Build Failed");
windowsBuildSuccess = false;
}
}
Debug.Log("Build Windows " + windowsBuildSuccess);
}
if (buildSettings.androidBuildYesNo)
{
androidBuildSuccess = false;
foreach (var item in bundlesBuiltAndroid)
{
string fileName = Path.GetFileName(item);
string BundleBuiltPath = userSettings.projectWinLoc + "/AssetBundles/Android/" + fileName;
Debug.Log(BundleBuiltPath);
if (File.Exists(BundleBuiltPath))
{
bundleBuildLogFull.Append(System.Environment.NewLine + BundleBuiltPath + " : Bundle Built successfully");
androidBuildSuccess = true;
}
else
{
bundleBuildLogFull.Append(System.Environment.NewLine + BundleBuiltPath + " : Bundle Build Failed");
androidBuildSuccess = false;
}
}
Debug.Log("Build Android " + androidBuildSuccess);
}
if (buildSettings.iOSBuildYesNo)
{
iOSBuildSuccess = false;
foreach (var item in bundlesBuiltiOS)
{
string fileName = Path.GetFileName(item);
string BundleBuiltPath = userSettings.projectWinLoc + "/AssetBundles/iOS/" + fileName;
Debug.Log(BundleBuiltPath);
if (File.Exists(BundleBuiltPath))
{
bundleBuildLogFull.Append(System.Environment.NewLine + BundleBuiltPath + " : Bundle Built successfully");
iOSBuildSuccess = true;
}
else
{
bundleBuildLogFull.Append(System.Environment.NewLine + BundleBuiltPath + " : Bundle Build Failed");
iOSBuildSuccess = false;
}
}
Debug.Log("Build success iOS " + iOSBuildSuccess);
}
if (userSettings.CTMode())
{
bundleBuildLogFull.Append(System.Environment.NewLine + " //////////////////////////////////////////BUNDLES TO CDN///////////////////////////////////");
bool windowsBuildMoved = false;
foreach (var item in bundlesBuiltWin)
{
Debug.Log(item);
if (File.Exists(item))
{
bundleBuildLogFull.Append(System.Environment.NewLine + item + " : Moved to CDN successfully");
windowsBuildMoved = true;
}
else
{
bundleBuildLogFull.Append(System.Environment.NewLine + item + " : Moved to CDN Failed");
windowsBuildMoved = false;
}
}
Debug.Log("Build Moved Win " + windowsBuildMoved);
foreach (var item in bundlesBuiltAndroid)
{
Debug.Log(item);
if (File.Exists(item))
{
bundleBuildLogFull.Append(System.Environment.NewLine + item + " : Moved to CDN successfully");
}
else
{
bundleBuildLogFull.Append(System.Environment.NewLine + item + " : Moved to CDN Failed");
}
}
Debug.Log("Build Moved Android " + androidBuildSuccess);
foreach (var item in bundlesBuiltiOS)
{
Debug.Log(item);
if (File.Exists(item))
{
bundleBuildLogFull.Append(System.Environment.NewLine + item + " : Moved to CDN successfully");
}
else
{
bundleBuildLogFull.Append(System.Environment.NewLine + item + " : Moved to CDN Failed");
}
}
Debug.Log("Build Moved iOS " + iOSBuildSuccess);
}
bundleBuildLogFull.Append(System.Environment.NewLine + " //////////////////////////////////////////WINDOWS BUILD LOGS///////////////////////////////////");
bundleBuildLogFull.Append(System.Environment.NewLine + bundleBuildLogWindows);
foreach (var item in buildLogsIN)
{
bundleBuildLogFull.Append(System.Environment.NewLine + " //////////////////////////////////////////BUILD LOG///////////////////////////////////");
bundleBuildLogFull.Append(System.Environment.NewLine + item);
//Debug.Log(item);
}
if (userSettings.CTMode())
{
bundleBuildLogFull.Append(System.Environment.NewLine + " //////////////////////////////////////////GIT LOGS///////////////////////////////////");
bundleBuildLogFull.Append(System.Environment.NewLine + bundleBuildLogGIT);
}
System.IO.File.WriteAllText(userSettings.projectWinLoc + "/Bundle Build Debug Log.txt", bundleBuildLogFull.ToString());
if (windowsBuildSuccess && androidBuildSuccess && iOSBuildSuccess)
{
EditorUtility.DisplayDialog("Complete", " Bundles built", "Ok");
}
else
{
EditorUtility.DisplayDialog("Failed", " theres was an issue building the bundle - check logs", "Ok");
}
}
}
}
