protected virtual void SetupStagingArea()
{
Directory.CreateDirectory(this.DataFolder);
this.CopyNativePlugins();
this.CopyVirtualRealityDependencies();
PostprocessBuildPlayer.InstallStreamingAssets(this.DataFolder);
if (this.UseIl2Cpp)
{
this.CopyVariationFolderIntoStagingArea();
string text = this.StagingArea + "/Data";
string text2 = this.DataFolder + "/Managed";
string text3 = text2 + "/Resources";
string text4 = text2 + "/Metadata";
IL2CPPUtils.RunIl2Cpp(text, this.GetPlatformProvider(this.m_PostProcessArgs.target), delegate(string s)
{
}, this.m_PostProcessArgs.usedClassRegistry, this.Development);
FileUtil.CreateOrCleanDirectory(text3);
IL2CPPUtils.CopyEmbeddedResourceFiles(text, text3);
FileUtil.CreateOrCleanDirectory(text4);
IL2CPPUtils.CopyMetadataFiles(text, text4);
IL2CPPUtils.CopySymmapFile(text + "/Native", text2);
}
if (this.InstallingIntoBuildsFolder)
{
this.CopyDataForBuildsFolder();
return;
}
if (!this.UseIl2Cpp)
{
this.CopyVariationFolderIntoStagingArea();
}
this.RenameFilesInStagingArea();
}
public static void PostProcess(BuildTarget target, string installPath, string stagingArea, string playerPackage, string companyName, string productName, int width, int height)
{
string str1 = stagingArea + "/DashboardBuild";
FileUtil.DeleteFileOrDirectory(str1);
FileUtil.CopyFileOrDirectory(playerPackage, str1);
FileUtil.MoveFileOrDirectory("Temp/unitystream.unity3d", str1 + "/widget.unity3d");
PostprocessBuildPlayer.InstallPlugins(str1 + "/Plugins", target);
string str2 = PostprocessBuildPlayer.GenerateBundleIdentifier(companyName, productName) + ".widget";
string[] strArray = new string[12]
{
"UNITY_WIDTH_PLUS32",
(width + 32).ToString(),
"UNITY_HEIGHT_PLUS32",
(height + 32).ToString(),
"UNITY_WIDTH",
width.ToString(),
"UNITY_HEIGHT",
height.ToString(),
"UNITY_BUNDLE_IDENTIFIER",
str2,
"UNITY_BUNDLE_NAME",
productName
};
FileUtil.ReplaceText(str1 + "/UnityWidget.html", strArray);
FileUtil.ReplaceText(str1 + "/Info.plist", strArray);
FileUtil.DeleteFileOrDirectory(installPath);
FileUtil.MoveFileOrDirectory(str1, installPath);
}
protected virtual void SetupStagingArea()
{
Directory.CreateDirectory(this.DataFolder);
this.CopyNativePlugins();
this.CopyVirtualRealityDependencies();
PostprocessBuildPlayer.InstallStreamingAssets(this.DataFolder);
if (this.UseIl2Cpp)
{
this.CopyVariationFolderIntoStagingArea();
string str1 = this.StagingArea + "/Data";
string destinationFolder = this.DataFolder + "/Managed";
string str2 = destinationFolder + "/Resources";
string str3 = destinationFolder + "/Metadata";
IL2CPPUtils.RunIl2Cpp(str1, this.GetPlatformProvider(this.m_PostProcessArgs.target), (System.Action <string>)(s => {}), this.m_PostProcessArgs.usedClassRegistry, this.Development);
FileUtil.CreateOrCleanDirectory(str2);
IL2CPPUtils.CopyEmbeddedResourceFiles(str1, str2);
FileUtil.CreateOrCleanDirectory(str3);
IL2CPPUtils.CopyMetadataFiles(str1, str3);
IL2CPPUtils.CopySymmapFile(str1 + "/Native", destinationFolder);
}
if (this.InstallingIntoBuildsFolder)
{
this.CopyDataForBuildsFolder();
}
else
{
if (!this.UseIl2Cpp)
{
this.CopyVariationFolderIntoStagingArea();
}
this.RenameFilesInStagingArea();
}
}
private void SetupStagingArea(BuildPostProcessArgs args, HashSet <string> filesToNotOverwrite)
{
List <string> cppPlugins;
if (GetCreateSolution(args) && (args.target == BuildTarget.StandaloneWindows || args.target == BuildTarget.StandaloneWindows64))
{
// For Windows Standalone player solution build, we want to copy plugins for all architectures as
// the ultimate CPU architecture choice can be made from Visual Studio
CopyNativePlugins(args, BuildTarget.StandaloneWindows, out cppPlugins);
CopyNativePlugins(args, BuildTarget.StandaloneWindows64, out cppPlugins);
}
else
{
CopyNativePlugins(args, args.target, out cppPlugins);
}
CreateApplicationData(args);
PostprocessBuildPlayer.InstallStreamingAssets(args.stagingAreaData, args.report);
if (GetInstallingIntoBuildsFolder(args))
{
CopyDataForBuildsFolder(args);
}
else
{
CopyVariationFolderIntoStagingArea(args, filesToNotOverwrite);
if (UseIl2Cpp)
{
var il2cppPlatformProvider = GetPlatformProvider(args);
IL2CPPUtils.RunIl2Cpp(args.stagingAreaData, il2cppPlatformProvider, (cppOutputDir) => CopyCppPlugins(args, cppOutputDir, cppPlugins), args.usedClassRegistry);
if (GetCreateSolution(args))
{
ProcessIl2CppOutputForSolution(args, il2cppPlatformProvider, cppPlugins);
}
else
{
ProcessIl2CppOutputForBinary(args);
}
}
else
{
var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(args.target);
var managedStrippingLevel = PlayerSettings.GetManagedStrippingLevel(buildTargetGroup);
AssemblyStripper.StripForMonoBackend(args.target, args.usedClassRegistry, managedStrippingLevel, args.report);
}
RenameFilesInStagingArea(args);
}
}
private void SetupStagingArea(BuildPostProcessArgs args, HashSet <string> filesToNotOverwrite)
{
List <string> cppPlugins;
CopyNativePlugins(args, out cppPlugins);
CreateApplicationData(args);
PostprocessBuildPlayer.InstallStreamingAssets(args.stagingAreaData, args.report);
if (GetInstallingIntoBuildsFolder(args))
{
CopyDataForBuildsFolder(args);
}
else
{
CopyVariationFolderIntoStagingArea(args);
if (GetCreateSolution(args))
{
CopyPlayerSolutionIntoStagingArea(args, filesToNotOverwrite);
}
if (UseIl2Cpp)
{
var il2cppPlatformProvider = GetPlatformProvider(args);
IL2CPPUtils.RunIl2Cpp(args.stagingAreaData, il2cppPlatformProvider, (cppOutputDir) => CopyCppPlugins(args, cppOutputDir, cppPlugins), args.usedClassRegistry);
if (GetCreateSolution(args))
{
ProcessIl2CppOutputForSolution(args, il2cppPlatformProvider, cppPlugins);
}
else
{
ProcessIl2CppOutputForBinary(args);
}
}
else
{
var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(args.target);
var managedStrippingLevel = PlayerSettings.GetManagedStrippingLevel(buildTargetGroup);
AssemblyStripper.StripForMonoBackend(args.target, args.usedClassRegistry, managedStrippingLevel, args.report);
}
RenameFilesInStagingArea(args);
}
}
private void SetupStagingArea(BuildPostProcessArgs args, HashSet <string> filesToNotOverwrite)
{
Directory.CreateDirectory(args.stagingAreaData);
List <string> cppPlugins;
CopyNativePlugins(args, out cppPlugins);
if (args.target == BuildTarget.StandaloneWindows ||
args.target == BuildTarget.StandaloneWindows64)
{
CreateApplicationData(args);
}
PostprocessBuildPlayer.InstallStreamingAssets(args.stagingAreaData, args.report);
if (GetInstallingIntoBuildsFolder(args))
{
CopyDataForBuildsFolder(args);
}
else
{
CopyVariationFolderIntoStagingArea(args);
if (GetCreateSolution(args))
{
CopyPlayerSolutionIntoStagingArea(args, filesToNotOverwrite);
}
if (UseIl2Cpp)
{
var il2cppPlatformProvider = GetPlatformProvider(args);
IL2CPPUtils.RunIl2Cpp(args.stagingAreaData, il2cppPlatformProvider, (cppOutputDir) => CopyCppPlugins(args, cppOutputDir, cppPlugins), args.usedClassRegistry);
if (GetCreateSolution(args))
{
ProcessIl2CppOutputForSolution(args, il2cppPlatformProvider, cppPlugins);
}
else
{
ProcessIl2CppOutputForBinary(args);
}
}
RenameFilesInStagingArea(args);
}
}
private string PickBuildLocation()
{
var target = EditorUserBuildSettings.activeBuildTarget;
var targetGroup = BuildPipeline.GetBuildTargetGroup(target);
var lastLocation = EditorUserBuildSettings.GetBuildLocation(target);
var extension = PostprocessBuildPlayer.GetExtensionForBuildTarget(targetGroup, target, BuildOptions.None);
var defaultName = FileUtil.GetLastPathNameComponent(lastLocation);
lastLocation = string.IsNullOrEmpty(lastLocation) ? string.Empty : Path.GetDirectoryName(lastLocation);
bool updateExistingBuild;
var location = EditorUtility.SaveBuildPanel(target, $"{GetBuildText()} {target}", lastLocation, defaultName, extension,
out updateExistingBuild);
if (!string.IsNullOrEmpty(location))
{
EditorUserBuildSettings.SetBuildLocation(target, location);
}
return(location);
}
protected virtual void SetupStagingArea()
{
Directory.CreateDirectory(this.DataFolder);
this.CopyNativePlugins();
if (this.m_PostProcessArgs.target == BuildTarget.StandaloneWindows || this.m_PostProcessArgs.target == BuildTarget.StandaloneWindows64)
{
this.CreateApplicationData();
}
PostprocessBuildPlayer.InstallStreamingAssets(this.DataFolder);
if (this.UseIl2Cpp)
{
this.CopyVariationFolderIntoStagingArea();
string text = this.StagingArea + "/Data";
string text2 = this.DataFolder + "/Managed";
string text3 = text2 + "/Resources";
string text4 = text2 + "/Metadata";
IL2CPPUtils.RunIl2Cpp(text, this.GetPlatformProvider(this.m_PostProcessArgs.target), delegate(string s)
{
}, this.m_PostProcessArgs.usedClassRegistry, this.Development);
FileUtil.CreateOrCleanDirectory(text3);
IL2CPPUtils.CopyEmbeddedResourceFiles(text, text3);
FileUtil.CreateOrCleanDirectory(text4);
IL2CPPUtils.CopyMetadataFiles(text, text4);
IL2CPPUtils.CopySymmapFile(text + "/Native/Data", text2);
}
if (this.InstallingIntoBuildsFolder)
{
this.CopyDataForBuildsFolder();
}
else
{
if (!this.UseIl2Cpp)
{
this.CopyVariationFolderIntoStagingArea();
}
this.RenameFilesInStagingArea();
this.m_PostProcessArgs.report.AddFilesRecursive(this.StagingArea, "");
this.m_PostProcessArgs.report.RelocateFiles(this.StagingArea, "");
}
}
protected virtual void SetupStagingArea()
{
Directory.CreateDirectory(this.DataFolder);
this.CopyNativePlugins();
PostprocessBuildPlayer.InstallStreamingAssets(this.DataFolder);
if (this.UseIl2Cpp)
{
this.CopyVariationFolderIntoStagingArea();
IL2CPPUtils.RunIl2Cpp(this.StagingArea + "/Data", this.GetPlatformProvider(this.m_PostProcessArgs.target), delegate(string s)
{
}, this.m_PostProcessArgs.usedClassRegistry);
}
if (this.InstallingIntoBuildsFolder)
{
return;
}
if (!this.UseIl2Cpp)
{
this.CopyVariationFolderIntoStagingArea();
}
this.RenameFilesInStagingArea();
}
private void PrepareNativeUnityLibs(PostProcessorContext context, string abi)
{
string pluginSourceFolder = context.Get <string>("AndroidPluginsPath");
string[] components = new string[] { this._stagingArea, "libs", abi };
string to = Paths.Combine(components);
string[] textArray2 = new string[] { TasksCommon.GetVariationsDirectory(context), "Libs" };
string str3 = Paths.Combine(textArray2);
string[] textArray3 = new string[] { this._stagingArea, "libs" };
Directory.CreateDirectory(Paths.Combine(textArray3));
string[] textArray4 = new string[] { str3, abi };
FileUtil.CopyFileOrDirectory(Paths.Combine(textArray4), to);
string[] textArray5 = new string[] { pluginSourceFolder, "libs", abi };
string str4 = Paths.Combine(textArray5);
string[] textArray6 = new string[] { to, "gdbserver" };
if (!File.Exists(Paths.Combine(textArray6)) && !PostprocessBuildPlayer.InstallPluginsByExtension(pluginSourceFolder, "gdbserver", string.Empty, to, false))
{
PostprocessBuildPlayer.InstallPluginsByExtension(str4, "gdbserver", string.Empty, to, false);
}
}
internal PlayerLauncherBuildOptions GetBuildOptions(string scenePath)
{
var buildOnly = false;
var runSettings = m_OverloadTestRunSettings as PlayerLauncherTestRunSettings;
if (runSettings != null)
{
buildOnly = runSettings.buildOnly;
}
var buildOptions = new BuildPlayerOptions();
var scenes = new List <string>()
{
scenePath
};
scenes.AddRange(EditorBuildSettings.scenes.Select(x => x.path));
buildOptions.scenes = scenes.ToArray();
buildOptions.options |= BuildOptions.Development | BuildOptions.ConnectToHost | BuildOptions.IncludeTestAssemblies | BuildOptions.StrictMode;
buildOptions.target = m_TargetPlatform;
if (EditorUserBuildSettings.waitForPlayerConnection)
{
buildOptions.options |= BuildOptions.WaitForPlayerConnection;
}
if (EditorUserBuildSettings.allowDebugging)
{
buildOptions.options |= BuildOptions.AllowDebugging;
}
if (EditorUserBuildSettings.installInBuildFolder)
{
buildOptions.options |= BuildOptions.InstallInBuildFolder;
}
else if (!buildOnly)
{
buildOptions.options |= BuildOptions.AutoRunPlayer;
}
var buildTargetGroup = EditorUserBuildSettings.activeBuildTargetGroup;
//Check if Lz4 is supported for the current buildtargetgroup and enable it if need be
if (PostprocessBuildPlayer.SupportsLz4Compression(buildTargetGroup, m_TargetPlatform))
{
if (EditorUserBuildSettings.GetCompressionType(buildTargetGroup) == Compression.Lz4)
{
buildOptions.options |= BuildOptions.CompressWithLz4;
}
else if (EditorUserBuildSettings.GetCompressionType(buildTargetGroup) == Compression.Lz4HC)
{
buildOptions.options |= BuildOptions.CompressWithLz4HC;
}
}
string buildLocation;
if (buildOnly)
{
buildLocation = buildOptions.locationPathName = runSettings.buildOnlyLocationPath;
}
else
{
var reduceBuildLocationPathLength = false;
//Some platforms hit MAX_PATH limits during the build process, in these cases minimize the path length
if ((m_TargetPlatform == BuildTarget.WSAPlayer)
#if !UNITY_2021_1_OR_NEWER
|| (m_TargetPlatform == BuildTarget.XboxOne)
#endif
)
{
reduceBuildLocationPathLength = true;
}
var uniqueTempPathInProject = FileUtil.GetUniqueTempPathInProject();
var playerDirectoryName = "PlayerWithTests";
//Some platforms hit MAX_PATH limits during the build process, in these cases minimize the path length
if (reduceBuildLocationPathLength)
{
playerDirectoryName = "PwT";
uniqueTempPathInProject = Path.GetTempFileName();
File.Delete(uniqueTempPathInProject);
Directory.CreateDirectory(uniqueTempPathInProject);
}
var tempPath = Path.GetFullPath(uniqueTempPathInProject);
buildLocation = Path.Combine(tempPath, playerDirectoryName);
// iOS builds create a folder with Xcode project instead of an executable, therefore no executable name is added
if (m_TargetPlatform == BuildTarget.iOS)
{
buildOptions.locationPathName = buildLocation;
}
else
{
string extensionForBuildTarget =
PostprocessBuildPlayer.GetExtensionForBuildTarget(buildTargetGroup, buildOptions.target,
buildOptions.options);
var playerExecutableName = "PlayerWithTests";
if (!string.IsNullOrEmpty(extensionForBuildTarget))
{
playerExecutableName += $".{extensionForBuildTarget}";
}
buildOptions.locationPathName = Path.Combine(buildLocation, playerExecutableName);
}
}
return(new PlayerLauncherBuildOptions
{
BuildPlayerOptions = ModifyBuildOptions(buildOptions),
PlayerDirectory = buildLocation,
});
}
private void SetupStagingArea(BuildPostProcessArgs args)
{
if (UseIl2Cpp && GetCreateSolution())
{
throw new Exception("CreateSolution is not supported with IL2CPP build");
}
Directory.CreateDirectory(args.stagingAreaData);
List <string> cppPlugins;
CopyNativePlugins(args, out cppPlugins);
if (args.target == BuildTarget.StandaloneWindows ||
args.target == BuildTarget.StandaloneWindows64)
{
CreateApplicationData(args);
}
PostprocessBuildPlayer.InstallStreamingAssets(args.stagingAreaData, args.report);
if (UseIl2Cpp)
{
CopyVariationFolderIntoStagingArea(args);
IL2CPPUtils.RunIl2Cpp(args.stagingAreaData, GetPlatformProvider(args), (cppOutputDir) => CopyCppPlugins(cppOutputDir, cppPlugins), args.usedClassRegistry);
// Move GameAssembly next to game executable
var il2cppOutputNativeDirectory = Path.Combine(args.stagingAreaData, "Native");
var gameAssemblyDirectory = GetDirectoryForGameAssembly(args);
foreach (var file in Directory.GetFiles(il2cppOutputNativeDirectory))
{
var fileName = Path.GetFileName(file);
if (fileName.StartsWith("."))
{
continue; // Skip files starting with ., as they weren't output by our tools and potentially belong to the OS (like .DS_Store on macOS)
}
FileUtil.MoveFileOrDirectory(file, Path.Combine(gameAssemblyDirectory, fileName));
}
if (PlaceIL2CPPSymbolMapNextToExecutable())
{
// Move symbol map to be next to game executable
FileUtil.MoveFileOrDirectory(Paths.Combine(il2cppOutputNativeDirectory, "Data", "SymbolMap"), Path.Combine(args.stagingArea, "SymbolMap"));
}
// Move il2cpp data directory one directory up
FileUtil.MoveFileOrDirectory(Path.Combine(il2cppOutputNativeDirectory, "Data"), Path.Combine(args.stagingAreaData, "il2cpp_data"));
// Native directory is supposed to be empty at this point
FileUtil.DeleteFileOrDirectory(il2cppOutputNativeDirectory);
var dataBackupFolder = Path.Combine(args.stagingArea, GetIl2CppDataBackupFolderName(args));
FileUtil.CreateOrCleanDirectory(dataBackupFolder);
// Move generated C++ code out of Data directory
FileUtil.MoveFileOrDirectory(Path.Combine(args.stagingAreaData, "il2cppOutput"), Path.Combine(dataBackupFolder, "il2cppOutput"));
if (IL2CPPUtils.UseIl2CppCodegenWithMonoBackend(BuildPipeline.GetBuildTargetGroup(args.target)))
{
// Are we using IL2CPP code generation with the Mono runtime? If so, strip the assemblies so we can use them for metadata.
StripAssembliesToLeaveOnlyMetadata(args.target, args.stagingAreaDataManaged);
}
else
{
// Otherwise, move them to temp data directory as il2cpp does not need managed assemblies to run
FileUtil.MoveFileOrDirectory(args.stagingAreaDataManaged, Path.Combine(dataBackupFolder, "Managed"));
}
ProcessPlatformSpecificIL2CPPOutput(args);
}
if (GetInstallingIntoBuildsFolder(args))
{
CopyDataForBuildsFolder(args);
}
else
{
if (!UseIl2Cpp)
{
CopyVariationFolderIntoStagingArea(args);
}
if (GetCreateSolution())
{
CopyPlayerSolutionIntoStagingArea(args);
}
RenameFilesInStagingArea(args);
}
}
private PlayerLauncherBuildOptions GetBuildOptions(string scenePath)
{
var buildOptions = new BuildPlayerOptions();
var reduceBuildLocationPathLength = false;
//Some platforms hit MAX_PATH limits during the build process, in these cases minimize the path length
if ((m_TargetPlatform == BuildTarget.WSAPlayer) || (m_TargetPlatform == BuildTarget.XboxOne))
{
reduceBuildLocationPathLength = true;
}
var scenes = new List <string>()
{
scenePath
};
scenes.AddRange(EditorBuildSettings.scenes.Select(x => x.path));
buildOptions.scenes = scenes.ToArray();
buildOptions.options |= BuildOptions.AutoRunPlayer | BuildOptions.Development | BuildOptions.ConnectToHost | BuildOptions.IncludeTestAssemblies | BuildOptions.StrictMode;
buildOptions.target = m_TargetPlatform;
if (EditorUserBuildSettings.waitForPlayerConnection)
{
buildOptions.options |= BuildOptions.WaitForPlayerConnection;
}
var buildTargetGroup = EditorUserBuildSettings.activeBuildTargetGroup;
//Check if Lz4 is supported for the current buildtargetgroup and enable it if need be
if (PostprocessBuildPlayer.SupportsLz4Compression(buildTargetGroup, m_TargetPlatform))
{
if (EditorUserBuildSettings.GetCompressionType(buildTargetGroup) == Compression.Lz4)
{
buildOptions.options |= BuildOptions.CompressWithLz4;
}
else if (EditorUserBuildSettings.GetCompressionType(buildTargetGroup) == Compression.Lz4HC)
{
buildOptions.options |= BuildOptions.CompressWithLz4HC;
}
}
var uniqueTempPathInProject = FileUtil.GetUniqueTempPathInProject();
var playerDirectoryName = reduceBuildLocationPathLength ? "PwT" : "PlayerWithTests";
if (reduceBuildLocationPathLength)
{
uniqueTempPathInProject = Path.GetTempFileName();
File.Delete(uniqueTempPathInProject);
Directory.CreateDirectory(uniqueTempPathInProject);
}
var tempPath = Path.GetFullPath(uniqueTempPathInProject);
var buildLocation = Path.Combine(tempPath, playerDirectoryName);
// iOS builds create a folder with Xcode project instead of an executable, therefore no executable name is added
if (m_TargetPlatform == BuildTarget.iOS)
{
buildOptions.locationPathName = buildLocation;
}
else
{
string extensionForBuildTarget = PostprocessBuildPlayer.GetExtensionForBuildTarget(buildTargetGroup, buildOptions.target, buildOptions.options);
var playerExecutableName = "PlayerWithTests";
playerExecutableName += string.Format(".{0}", extensionForBuildTarget);
buildOptions.locationPathName = Path.Combine(buildLocation, playerExecutableName);
}
return(new PlayerLauncherBuildOptions
{
BuildPlayerOptions = ModifyBuildOptions(buildOptions),
PlayerDirectory = buildLocation,
});
}
private static BuildPlayerOptions GetBuildOptions(Scene scene)
{
BuildPlayerOptions options = new BuildPlayerOptions();
options.scenes = new string[] { scene.path };
options.options |= BuildOptions.AutoRunPlayer | BuildOptions.Development;
options.target = EditorUserBuildSettings.activeBuildTarget;
string str = Path.Combine(Path.Combine(FileUtil.GetUniqueTempPathInProject(), "TestRun"), "test." + PostprocessBuildPlayer.GetExtensionForBuildTarget(options.target, options.options));
options.locationPathName = str;
return(options);
}
private void SetupStagingArea(BuildPostProcessArgs args)
{
if (this.UseIl2Cpp && this.GetCreateSolution())
{
throw new Exception("CreateSolution is not supported with IL2CPP build");
}
Directory.CreateDirectory(args.stagingAreaData);
this.CopyNativePlugins(args);
if (args.target == BuildTarget.StandaloneWindows || args.target == BuildTarget.StandaloneWindows64)
{
this.CreateApplicationData(args);
}
PostprocessBuildPlayer.InstallStreamingAssets(args.stagingAreaData, args.report);
if (this.UseIl2Cpp)
{
this.CopyVariationFolderIntoStagingArea(args);
IL2CPPUtils.RunIl2Cpp(args.stagingAreaData, this.GetPlatformProvider(args), null, args.usedClassRegistry);
string text = Path.Combine(args.stagingAreaData, "Native");
string directoryForGameAssembly = this.GetDirectoryForGameAssembly(args);
string[] files = Directory.GetFiles(text);
for (int i = 0; i < files.Length; i++)
{
string text2 = files[i];
string fileName = Path.GetFileName(text2);
if (!fileName.StartsWith("."))
{
FileUtil.MoveFileOrDirectory(text2, Path.Combine(directoryForGameAssembly, fileName));
}
}
if (this.PlaceIL2CPPSymbolMapNextToExecutable())
{
FileUtil.MoveFileOrDirectory(Paths.Combine(new string[]
{
text,
"Data",
"SymbolMap"
}), Path.Combine(args.stagingArea, "SymbolMap"));
}
FileUtil.MoveFileOrDirectory(Path.Combine(text, "Data"), Path.Combine(args.stagingAreaData, "il2cpp_data"));
FileUtil.DeleteFileOrDirectory(text);
string text3 = Path.Combine(args.stagingArea, this.GetIl2CppDataBackupFolderName(args));
FileUtil.CreateOrCleanDirectory(text3);
FileUtil.MoveFileOrDirectory(Path.Combine(args.stagingAreaData, "il2cppOutput"), Path.Combine(text3, "il2cppOutput"));
if (IL2CPPUtils.UseIl2CppCodegenWithMonoBackend(BuildPipeline.GetBuildTargetGroup(args.target)))
{
DesktopStandalonePostProcessor.StripAssembliesToLeaveOnlyMetadata(args.target, args.stagingAreaDataManaged);
}
else
{
FileUtil.MoveFileOrDirectory(args.stagingAreaDataManaged, Path.Combine(text3, "Managed"));
}
this.ProcessPlatformSpecificIL2CPPOutput(args);
}
if (this.GetInstallingIntoBuildsFolder(args))
{
this.CopyDataForBuildsFolder(args);
}
else
{
if (!this.UseIl2Cpp)
{
this.CopyVariationFolderIntoStagingArea(args);
}
if (this.GetCreateSolution())
{
this.CopyPlayerSolutionIntoStagingArea(args);
}
this.RenameFilesInStagingArea(args);
}
}