HELP! I got error CS1525 Unexpected symbol `{' (I marked error with 2 ** at line 325)

// // CreateAssetBundles.cs // // The class that does all the work in Bundle Creator. // It creates the asset bundles in the specified folder and // stores the information in a control file and a contents file. // // The MIT License (MIT) // // Copyright (c) 2013 Niklas Borglund // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions:

// The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE.

using UnityEngine; using UnityEditor; using System.IO; using System.Collections.Generic;

public class CreateAssetBundles { public static string bundleControlFileName = "bundleControlFile.txt"; public static string bundleContentsFileName = "bundleContents.txt";

 public static void ReadBundleControlFile(string path, Dictionary<string, int> bundleVersions)
 {
     if (bundleVersions == null)
     {
         bundleVersions = new Dictionary<string, int>();
     }
     else
     {
         bundleVersions.Clear();
     }

     if (File.Exists(path))
     {
         StreamReader streamReader = new StreamReader(path);
         string currentLine;
         while ((currentLine = streamReader.ReadLine()) != null)
         {
             if (currentLine.StartsWith("BundleName:"))
             {
                 string bundleName = currentLine.Substring("BundleName:".Length);
                 int bundleVersion = 0;

                 //if the bundlename is there, the versionNumber should be on the next line
                 //otherwise there's an error
                 string nextLine = streamReader.ReadLine();
                 if (nextLine != null && nextLine.StartsWith("VersionNumber:"))
                 {
                     bundleVersion = System.Convert.ToInt32(nextLine.Substring("VersionNumber:".Length));
                 }
                 else
                 {
                     Debug.LogError("CreateAssetBundles.cs: Error reading bundle control file! - Delete the current control file to start over");
                 }

                 bundleVersions.Add(bundleName, bundleVersion);
             }
         }

         streamReader.Close();
     }
 }
 public static void ReadBundleContentsFile(string path, Dictionary<string, List<string>> bundleContents)
 {
     if (bundleContents == null)
     {
         bundleContents = new Dictionary<string, List<string>>();
     }
     else
     {
         bundleContents.Clear();
     }
     if (File.Exists(path))
     {
         StreamReader streamReader = new StreamReader(path);
         string currentLine;
         while ((currentLine = streamReader.ReadLine()) != null)
         {
             if (currentLine.StartsWith("BundleName:"))
             {
                 string bundleName = currentLine.Substring("BundleName:".Length);

                 int numberOfAssets = 0;
                 string nextLine = streamReader.ReadLine();
                 if (nextLine != null && nextLine.StartsWith("NumberOfAssets:"))
                 {
                     numberOfAssets = System.Convert.ToInt32(nextLine.Substring("NumberOfAssets:".Length));
                 }
                 else
                 {
                     Debug.LogError("CreateAssetBundles.cs: Error reading bundle contents file! - Delete the current control file to start over");
                     break;
                 }
                 List<string> assetsInBundle = new List<string>();
                 for (int i = 0; i < numberOfAssets; i++)
                 {
                     assetsInBundle.Add(streamReader.ReadLine());
                 }

                 bundleContents.Add(bundleName, assetsInBundle);
             }
         }

         streamReader.Close();
     }
 }
 static void WriteBundleControlFile(string path, Dictionary<string, int> bundleVersions, string exportPath)
 {
     StreamWriter streamWriter = new StreamWriter(path);
     foreach (KeyValuePair<string, int> bundleVersion in bundleVersions)
     {
         if (File.Exists(exportPath + bundleVersion.Key))
         {
             streamWriter.WriteLine("BundleName:" + bundleVersion.Key);
             streamWriter.WriteLine("VersionNumber:" + bundleVersion.Value.ToString());

             //For readability in the txt file, add an empty line
             streamWriter.WriteLine();
         }
     }
     streamWriter.Close();
 }
 static void WriteBundleContentsFile(string path, Dictionary<string, List<string>> bundleContents, string exportPath)
 {
     StreamWriter streamWriter = new StreamWriter(path);
     foreach (KeyValuePair<string, List<string>> asset in bundleContents)
     {
         if (File.Exists(exportPath + asset.Key))
         {
             //For readability in the txt file
             streamWriter.WriteLine("BundleName:" + asset.Key);
             streamWriter.WriteLine("NumberOfAssets:" + asset.Value.Count);
             foreach (string assetName in asset.Value)
             {
                 streamWriter.WriteLine(assetName);
             }
         }
     }
     streamWriter.Close();
 }

 public static bool ExportAssetBundleFolders(AssetBundleWindow thisWindow)
 {
     //To keep track of the versions with the control file
     Dictionary<string, int> bundleVersions = new Dictionary<string, int>();

     //A list of all the assets in each bundle
     //This will be saved into the file bundleContents.txt;
     Dictionary<string, List<string>> bundleContents = new Dictionary<string, List<string>>();

     //The AssetBundle folder
     string path = Application.dataPath + thisWindow.exportLocation;

     //The folder location in the editor
     string assetBundleFolderLocation = thisWindow.assetBundleFolderLocation;

     //Create directory if it does not exist
     if (!Directory.Exists(path))
     {
         Directory.CreateDirectory(path);
     }
     //Read and parse the control file
     ReadBundleControlFile(path + bundleControlFileName, bundleVersions);
     //Read and parse the contents file
     ReadBundleContentsFile(path + bundleContentsFileName, bundleContents);

     //Check if the directory exist
     if (!Directory.Exists(Application.dataPath + assetBundleFolderLocation))
     {
         Debug.LogError("Specified 'AssetBundles folder' does not exist! Open Assets->Bundle Creator->Asset Bundle Creator to correct it");
         return false;
     }

     int createdBundles = 0;
     string[] directoryNames = Directory.GetDirectories(Application.dataPath + assetBundleFolderLocation);
     foreach (string folderPath in directoryNames)
     {
         //Generate the name of this asset bundle
         DirectoryInfo dirInfo = new DirectoryInfo(folderPath);

         //if the user has specified a build target, add a prefix to the bundle name
         string bundleName = "";
         string directoryName = dirInfo.Name;
         if (thisWindow.setLowerCaseName)
         {
             directoryName = directoryName.ToLower();
         }

         if (!thisWindow.optionalSettings)
         {
             bundleName = directoryName + thisWindow.bundleFileExtension;
         }
         else
         {
             bundleName = thisWindow.buildTarget.ToString().ToLower() + "_" + directoryName + thisWindow.bundleFileExtension;
         }

         List<Object> toInclude = new List<Object>();
         string[] assetsInFolder = Directory.GetFiles(folderPath);

         //To save in the contents file(information)
         List<string> assetListInFolder = new List<string>();

         foreach (string asset in assetsInFolder)
         {
             string thisFileName = Path.GetFileName(asset);
             if (asset.EndsWith(".prefab"))
             {
                 string internalFilePath = "Assets" + assetBundleFolderLocation + dirInfo.Name + "/" + thisFileName;
                 GameObject prefab = (GameObject)AssetDatabase.LoadAssetAtPath(internalFilePath, typeof(GameObject));
                 toInclude.Add((Object)prefab);

                 assetListInFolder.Add(thisFileName);
             }
             else if (!asset.EndsWith(".meta"))
             {
                 //toInclude.AddRange(AssetDatabase.LoadAllAssetsAtPath(assetBundleFolderLocation + dirInfo.Name + "/" + thisFileName));
                 string internalFilePath = "Assets" + assetBundleFolderLocation + dirInfo.Name + "/" + thisFileName;
                 toInclude.Add((Object)AssetDatabase.LoadAssetAtPath(internalFilePath, typeof(Object)));
                 assetListInFolder.Add(thisFileName);
             }
         }

         //Build only if there are any files in this folder
         if (toInclude.Count > 0)
         {
             //Check if the bundle already have been created
             if (bundleContents.ContainsKey(bundleName))
             {
                 bundleContents.Remove(bundleName);
             }
             //Add to the contents text file
             bundleContents.Add(bundleName, assetListInFolder);

             Debug.Log("Building bundle:" + bundleName);
             if (!BuildAssetBundle(thisWindow, toInclude, path + bundleName))
             {
                 return false; //It failed, abort everything
             }
             createdBundles++;

             //Checks to save the version numbers
             int versionNumber = -1;
             bundleVersions.TryGetValue(bundleName, out versionNumber);

             if (versionNumber == -1)
             {
                 versionNumber = 1;
             }
             else
             {
                 versionNumber++;
                 bundleVersions.Remove(bundleName);
             }
             bundleVersions.Add(bundleName, versionNumber);
         }
         toInclude.Clear();
     }

     WriteBundleControlFile(path + bundleControlFileName, bundleVersions, path);
     WriteBundleContentsFile(path + bundleContentsFileName, bundleContents, path);
     bundleVersions.Clear();
     foreach (KeyValuePair<string, List<string>> pair in bundleContents)
     {
         pair.Value.Clear();
     }
     bundleContents.Clear();

     Debug.Log("***Successfully Created " + createdBundles + " AssetBundles!***");
     return true;
 }

 /// <summary>
 /// Helper function to build an asset bundle
 /// This will iterate through all the settings of the AssetBundleWindow and set them accordingly
 /// </summary>
 /// <param name="thisWindow"></param>
 /// <param name="toInclude"></param>
 /// <param name="bundlePath"></param>
 public static bool BuildAssetBundle(AssetBundleWindow thisWindow, List<Object> toInclude, string bundlePath)
 {
     BuildAssetBundleOptions buildAssetOptions = 0;
     if (thisWindow.buildAssetBundleOptions)
     {
         if (thisWindow.collectDependencies)
         {
             if (buildAssetOptions == 0)
             {
                 buildAssetOptions = BuildAssetBundleOptions.CollectDependencies;
             }
             else
             {
                 buildAssetOptions |= BuildAssetBundleOptions.CollectDependencies;
             }
         }
         if (thisWindow.completeAssets)
         {
             if (buildAssetOptions == 0)
             {
                 buildAssetOptions = BuildAssetBundleOptions.CompleteAssets;
             }
             else
             {
                 buildAssetOptions |= BuildAssetBundleOptions.CompleteAssets;
             }
         }
         if (thisWindow.disableWriteTypeTree)
         {
             if (buildAssetOptions == 0)
             {
                 buildAssetOptions = BuildAssetBundleOptions.DisableWriteTypeTree;
             }
             else
             {
                 buildAssetOptions |= BuildAssetBundleOptions.DisableWriteTypeTree;
             }
         }
         if (thisWindow.deterministicAssetBundle)
         {
             if (buildAssetOptions == 0)
             {
                 buildAssetOptions = BuildAssetBundleOptions.DeterministicAssetBundle;
             }
             else
             {
                 buildAssetOptions |= BuildAssetBundleOptions.DeterministicAssetBundle;
             }
         }
         if (thisWindow.uncompressedAssetBundle)
         {
             if (buildAssetOptions == 0)
             {
                 buildAssetOptions = BuildAssetBundleOptions.UncompressedAssetBundle;
             }
             else
             {
                 buildAssetOptions |= BuildAssetBundleOptions.UncompressedAssetBundle;
             }
         }
     }

     //If none of "BuildAssetBundleOptions" or "Optional Settings" are set, then create without dependency tracking
     if (!thisWindow.buildAssetBundleOptions && !thisWindow.optionalSettings)
     {
          **if (!BuildPipeline.BuildAssetBundle(null, toInclude.ToArray(), bundlePath)
         {**
             return false;
         }
     }
     else
     {
         if (buildAssetOptions == 0) //If it's still zero, set default values
         {
             Debug.LogWarning("No BuildAssetBundleOptions are set, reverting back to dependency tracking. If you want no dependency tracking uncheck the 'BuildAssetBundleOptions' && 'Optional Settings' toggles all together");
             buildAssetOptions = BuildAssetBundleOptions.CollectDependencies | BuildAssetBundleOptions.CompleteAssets;
             thisWindow.buildAssetBundleOptions = true;
             thisWindow.collectDependencies = true;
             thisWindow.completeAssets = true;
         }
         if (thisWindow.optionalSettings) //Support for different build targets
         {
             if (!BuildPipeline.BuildAssetBundle(null, toInclude.ToArray(), bundlePath, buildAssetOptions, thisWindow.buildTarget))
             {
                 return false;
             }
         }
         else
         {
             if (!BuildPipeline.BuildAssetBundle(null, toInclude.ToArray(), bundlePath, buildAssetOptions))
             {
                 return false;
             }
         }
     }
     return true;
 }

}