//--------------------------------------------------------------------------------------------
// 打包场景文件
static public void BuildGameScene(string file, List <string> fLst, BuildTarget tgt, GameBundleVersionControl version)
{
//BuildOptions op = BuildOptions.BuildAdditionalStreamedScenes;
//string szMsg = BuildPipeline.BuildPlayer(fLst.ToArray(), file, tgt, op);
file = file.ToLower();
string pkgName = Path.GetFileName(file);
pkgName = pkgName.ToLower();
bool needPackage = false;
foreach (string n in fLst)
{
string sceneFileName = ArchiveUtil.NtfPathAfterAssets(n).ToLower();
if (version.UpdateFileMD5(sceneFileName, pkgName))
{
needPackage = true;
break;
}
}
if (!needPackage)
{
return;
}
string szMsg = BuildPipeline.BuildStreamedSceneAssetBundle(fLst.ToArray(), file, tgt);
if (string.IsNullOrEmpty(szMsg))
{
AppendResPackItm(fLst.ToArray(), file, tgt);
version.IncreasePackageVersion(pkgName);
szMsg = @"操作成功";
}
EditorUtility.DisplayDialog(@"操作已结束", @"消息: " + szMsg, "Ok");
}
public void prepare(Dictionary <string, int> variables)
{
//Attempt to replace variables
if (resourcePath.IndexOf('{') > 0)
{
int varStart = resourcePath.IndexOf('$') + 1;
int varLength = resourcePath.IndexOf('}') - varStart;
string variableName = resourcePath.Substring(varStart, varLength);
string substituteString = "{$" + variableName + "}";
Debug.Log("Replacing variable " + variableName + " in " + resourcePath + " with " + variables[variableName]);
if (variables.ContainsKey(variableName))
{
resourcePath = resourcePath.Replace(substituteString, variables[variableName].ToString());
}
}
Debug.Log("Attempting to jump to script file at " + resourcePath);
if (!File.Exists(novelPath + "/script/" + resourcePath))
{
using (ZipFile scriptZip = ZipFile.Read(novelPath + "/script.zip")) {
string fileName = resourcePath.Substring(resourcePath.LastIndexOf('/') + 1);
resourcePath = ArchiveUtil.extractFromZipFile(scriptZip, fileName, VisualNovel.cacheDirectory);
}
//resourcePath = VisualNovel.cacheDirectory + "/script/" + resourcePath;
}
else
{
resourcePath = novelPath + "/script/" + resourcePath;
}
}
//--------------------------------------------------------------------------------------------
// 测试版游戏打包: 启动程序/资源包/场景包
void OnBuildGameTest(Rect rct)
{
if (GUI.Button(rct, @"临时版本"))
{
string szMsg = "";
List <TglItem> selGms = mGameLst.GetSelItems();
if (selGms.Count <= 0)
{
szMsg = @"请选择要构建的游戏";
EditorUtility.DisplayDialog(@"操作提示", szMsg, "Ok");
return;
}
szMsg = @"确定要构建选中的游戏吗? 这个过程会很漫长,请耐心等待直到弹出结果窗口.";
if (EditorUtility.DisplayDialog(@"游戏发布", szMsg, "Ok", "Cancel"))
{
int nCount = 0;
GamePackUI gm = null;
foreach (TglItem itm in selGms)
{
string sGm = ArchiveUtil.GetLastPath(itm.mName);
if (mGameRes.TryGetValue(sGm.ToLower(), out gm))
{
if (gm.BuildTempGame(mTgtCtrl.GetSelTarget()))
{
++nCount;
}
}
}
szMsg = @"消息: 成功打包 [";
szMsg += (nCount.ToString() + @"] 个游戏, 有 [");
szMsg += ((selGms.Count - nCount).ToString() + @"] 个游戏打包失败");
EditorUtility.DisplayDialog(@"操作已结束", szMsg, "Ok");
}
}
}
//-----------------------------------------------------------------------------
public static string NtfPack(List <string> vPths, List <string> vfAry, string file, BuildTarget tgt, bool silence
, GameBundleVersionControl version, PackageVersion.Version cfgVersion)
{
List <string> fAry = new List <string>();
if (vfAry != null)
{
fAry.AddRange(vfAry);
}
foreach (string sPth in vPths)
{
List <string> vfs = ArchiveUtil.NtfGetFiles(sPth, true, ArchiveUtil.mSkips);
fAry.AddRange(vfs);
}
BuildGameCMD.BuildGamePack(file, fAry, tgt, silence, version);
string packageName = Path.GetFileName(file);
packageName = packageName.ToLower();
if (version.m_version.HavePackage(packageName))
{
PackageVersion.Version v = version.m_version.LookupPackageVersion(packageName);
v.m_isExternPackage = cfgVersion.m_isExternPackage;
v.m_isAliveInRuntime = cfgVersion.m_isAliveInRuntime;
version.m_version.AddPackage(packageName, v);
}
return(packageName);
}
public void ExtractFiles()
{
try
{
archivePath = form1.archivePath;
archiveName = FileUtil.GetFileNameWithoutExtensionByFilePath(archivePath);
if (FileUtil.FileSize(archivePath) > 0)
{
ComponentsUtil.AppendTextToRichTextBox(form1.GetRichTextBoxInfo(), "\tStep1:Extract archive files", Color.Blue, true);
//obtain desired dataExtractedPath
dataExtractedPath = FileUtil.GetPathExtractedArchive(archiveName);
//start extract data to specified location
ArchiveUtil.UnzipFile(archivePath, dataExtractedPath);
//set path to relevant Info from .meta file
form1.metaDataExtractedPath = FileUtil.GetPathOfExtractedMetaFile(dataExtractedPath);
ComponentsUtil.AppendTextToRichTextBox(form1.GetRichTextBoxInfo(), "\t\tOK...", Color.Blue, true);
//activate button of Load DB
ComponentsUtil.SetButtonVisibility(form1.GetLoadButton());
}
else
{
ComponentsUtil.AppendTextToRichTextBox(form1.GetRichTextBoxInfo(), "Archive size is 0", Color.Red, true);
}
} catch (Exception ex) { throw ex; };
}
//------------------------------------------------------------------------------------------------------------------
//
// 打包升级用资源
//
//--------------------------------------------------------------------------------------------
// 打包升级用资源
void OnLyrPackUpdate(BuildPackWindow src, float fx, float fy)
{
string verPth = "PackVers/";
if (GUI.Button(new Rect(fx + 355, fy, 40, 20), @"比较"))
{
NtfCompare(src);
}
float fw = 335;
GUI.Label(new Rect(fx, fy + 25, fw, 20), @"基础版本: " + mfCsv0);
if (GUI.Button(new Rect(fx + fw + 20, fy + 25, 40, 20), @"查找"))
{
string fl = EditorUtility.OpenFilePanel(@"源版本文件", verPth, "csv");
if (fl.Length > 0)
{
mfCsv0 = ArchiveUtil.NtfPathBeginPackVers(fl);
NtfCompare(src);
}
}
GUI.Label(new Rect(fx, fy + 50, fw, 20), @"比对版本: " + mfCsv1);
if (GUI.Button(new Rect(fx + fw + 20, fy + 50, 40, 20), @"查找"))
{
string fl = EditorUtility.OpenFilePanel(@"目标版本文件", verPth, "csv");
if (fl.Length > 0)
{
mfCsv1 = ArchiveUtil.NtfPathBeginPackVers(fl);
NtfCompare(src);
}
}
mCmpView.OnDrawView(fx, fy + 75, mCmpFile.ToArray());
}
public void NtfSearchPackVers()
{
string verPth = "PackVers/";
mVerList = ArchiveUtil.NtfGetFiles(verPth, false, "*.csv");
PackVerCfg.NtfLoadVerCfg("PackVers/VerConfig.txt");
NtfRefreshItemVer();
}
//--------------------------------------------------------------------------------------------
// 生成对应文件的 Object 对象
static public List <Object> BuildObjectList(ref BuildArgs vArgs, BundleVersionControl version, ref bool isNeedPackage)
{
isNeedPackage = false;
string szPckNm = Path.GetFileName(vArgs.vPack);
szPckNm = szPckNm.ToLower();
List <Object> objList = new List <Object>();
foreach (string fileName in vArgs.fAry)
{
string szt = fileName.ToLower();
if (szt.EndsWith(".unity"))
{
Debug.LogWarning("BuildPipeline Skip file = " + fileName);
continue;
}
if (szt.EndsWith(".unitypackage"))
{
Debug.LogWarning("BuildPipeline Skip file = " + fileName);
continue;
}
string fl = ArchiveUtil.NtfPathBeginAssets(fileName);
fl = fl.Replace('\\', '/');
string szKey = ArchiveUtil.NtfPathAfterAssets(fl).ToLower();
if (version != null && version.UpdateFileMD5(szKey, szPckNm) == false)
{//MD5相同，不用打包
}
else
{
isNeedPackage = true;
}
Object obj = AssetDatabase.LoadMainAssetAtPath(fl);
if (null == obj)
{
Debug.LogWarning("BuildPipeline LOAD failed file = " + fileName);
continue;
}
objList.Add(obj);
vArgs.kAry.Add(szKey);
ResPackItm itm = new ResPackItm();
itm.mType = 0; // 普通资源
itm.mfVer = 1; //// 需要查找对应版本号
itm.mFile = szKey;
itm.mPack = szPckNm;
vArgs.vTbl.Add(szKey, itm);
}
//更新package对应的版本号
if (version != null && isNeedPackage)
{
version.IncreasePackageVersion(szPckNm);
}
return(objList);
}
//--------------------------------------------------------------------------------------------
// 搜索打包用文件
static public List <string> SearchPackFiles(List <string> pthLst)
{
List <string> files = new List <string>();
foreach (string pth in pthLst)
{
List <string> fList = ArchiveUtil.NtfGetFiles(pth, true);
files.AddRange(fList);
}
return(files);
}
//--------------------------------------------------------------------------------------------
void NtfRefreshScene()
{
mScnCtrl.ResetCtrl();
List <string> vAry = ArchiveUtil.NtfGetFiles(GetGamePath(), true, "*.unity");
foreach (string sPth in vAry)
{
string sf = ArchiveUtil.NtfPathAfter(mPath, sPth);
mScnCtrl.AddItem(new TglItem(true, sf));
}
}
public override async Task RecordMetadata()
{
var obj = new JObject();
foreach (var(key, value) in metadataCache)
{
obj[key] = await value;
}
await ArchiveUtil.AddStringToTar(tarStream, TransientMetadataPath, JsonConvert.SerializeObject(obj));
}
private async Task WriteWorkspace(Stream workspaceStream)
{
try {
Directory.CreateDirectory(WorkspaceDir);
await using var tarStream = new TarInputStream(workspaceStream);
await ArchiveUtil.ExtractTar(tarStream, WorkspaceDir);
}
finally {
workspaceStream.Close();
}
}
//-----------------------------------------------------------------------------
// 打包场景(*.unity)资源
public void OnBuildScene(BuildTarget tgt)
{
List <string> vScn = new List <string>();
List <TglItem> vItms = mScnCtrl.GetSelItems();
foreach (TglItem itm in vItms)
{
string sf = GetGamePath() + itm.mName;
vScn.Add(sf);
}
string szTgtNm = BuildGameCMD.GetTargetName(tgt);
string szPath = BuildGameCMD.GetBuildFolder(tgt);
string szDefaultPath = BuildGameCMD.GetBuildFolder(mGmWind.GetTarget());
string saveFolder = EditorUtility.SaveFolderPanel("Save Pack File", szDefaultPath, "");
if (saveFolder == "")
{
return;
}
m_versionControl.LoadProject(saveFolder);
if (mbSingle)
{
string file = EditorUtility.SaveFilePanel("Save Scene File", szPath, mGame + szTgtNm, "unity3d");
if (file.Length > 0)
{
BuildGameCMD.BuildGameScene(file, vScn, tgt, m_versionControl);
}
}
else
{
string szMsg;
int nCount = 0;
foreach (string sf in vScn)
{
string nsf = szPath + "/" + ArchiveUtil.GetFileName(sf) + ".unity3d";
szMsg = BuildGameCMD.BuildGameScene(nsf, sf, tgt, m_versionControl);
if (!string.IsNullOrEmpty(szMsg))
{
Debug.LogWarning("BuildGameScene Msg = " + szMsg);
}
else
{
++nCount;
}
}
szMsg = @"消息: 成功打包 [";
szMsg += (nCount.ToString() + @"] 个场景, 有 [");
szMsg += ((vScn.Count - nCount).ToString() + @"] 个场景打包失败");
EditorUtility.DisplayDialog(@"操作已结束", szMsg, "Ok");
}
m_versionControl.SaveProject(saveFolder);
}
//--------------------------------------------------------------------------------------------
// 点击游戏列表
void OnClickGameList(TglItem itm, UIToggleCtrl frm)
{
//if (itm.mbSel)
{
GamePackUI gm = null;
string sGm = ArchiveUtil.GetLastPath(itm.mName);
mGameRes.TryGetValue(sGm.ToLower(), out gm);
if (gm != mpSelGM)
{
mpSelGM = gm;
}
}
}
public async Task WriteWorkspace(Stream stream, CancellationToken cancellationToken)
{
await using var tarStream = new TarOutputStream(stream);
foreach (var inputHandler in inputHandlers)
{
cancellationToken.ThrowIfCancellationRequested();
var file = await inputHandler.handler(cancellationToken);
await ArchiveUtil.AddFileOrDirToTar(tarStream, inputHandler.path, file);
}
}
public VerItemMng mVerMng; // 版本管理器
//--------------------------------------------------------------------------------------------
// 启动
void OnEnable()
{
ArchiveUtil.NtfInitSkips();
PackVerCfg.NtfLoadVerCfg("PackVers/VerConfig.txt");
mVerMng = new VerItemMng();
mPckLyr = new CLyrPackRes();
mVerLyr = new CLyrVerInfor();
mCsvView = new CLyrViewCsv(950, 280);
mVerMng.NtfSearchPackVers(); // 搜索已经存在的版本文件
//mPckLyr.NtfCompare(this);
}
//--------------------------------------------------------------------------------------------
// 刷新公共资源列表
void NtfRefreshPublic()
{
mPubLst.ResetCtrl();
List <string> pths = ArchiveUtil.NtfGetDirs(Application.dataPath, false, ArchiveUtil.mSkips);
foreach (string sPth in pths)
{
string sl = sPth.ToLower();
if (!sl.Contains("resources"))
{
mPubLst.AddItem(new TglItem(true, sPth));
}
}
}
protected override async Task <string> RecordBuildSchema(Func <Task <string> > readBuildSchema)
{
var result = await readBuildSchema();
using var _ = await tarLock.LockAsync();
if (!hasRecordedSchema)
{
await ArchiveUtil.AddFileToTar(tarStream, BuildSchemaPath, SchemaFile);
hasRecordedSchema = true;
}
return(result);
}
public override async Task <string> RecordArtifact(string path, Func <string, Task <string> > fetch)
{
var file = await fetch(cacheDir);
using var _ = await tarLock.LockAsync();
if (!recordedArtifacts.Contains(path))
{
await ArchiveUtil.AddFileToTar(tarStream, ArtifactPath(path), file);
recordedArtifacts.Add(path);
}
return(file);
}
public override async Task <(string hash, string installDir)> GetInstalledSdkDir(SdkInfo sdk)
{
var(hash, installDir) = await base.GetInstalledSdkDir(sdk);
using var _ = await archiveRecorder.tarLock.LockAsync();
if (!archiveRecorder.recordedSdks.Contains(hash))
{
await ArchiveUtil.AddDirToTar(archiveRecorder.tarStream, SdkPath(hash), Path.GetFullPath(Path.Combine(installDir, "..")));
archiveRecorder.recordedSdks.Add(hash);
}
return(hash, installDir);
}
protected override async Task <string> RecordRepoConfig(Func <Task <string> > readRepoConfig)
{
var result = await readRepoConfig();
using var _ = await tarLock.LockAsync();
if (!hasRecordedRepoConfig)
{
await ArchiveUtil.AddFileToTar(tarStream, RepoConfigPath, Path.Combine(ConfDir, "repos.toml"));
hasRecordedRepoConfig = true;
}
return(result);
}
//--------------------------------------------------------------------------------------------
void OnFirstGame()
{
List <TglItem> itms = mGameLst.GetItems();
if (itms.Count > 0)
{
itms[0].mbSel = true;
GamePackUI gm = null;
string sGm = ArchiveUtil.GetLastPath(itms[0].mName);
mGameRes.TryGetValue(sGm.ToLower(), out gm);
if (gm != mpSelGM)
{
mpSelGM = gm;
}
}
}
/**
* Constructs a new ScriptRunner object to be used to promote files from the source location, specified in the OptionWrapper.
* This can be a directory or a zip archive. If it is a zip it will be extracted to a temporary directory.
* @param pCommandLineWrapper Container for all command line arguments.
*/
private ScriptRunner(CommandLineWrapper pCommandLineWrapper)
{
mCommandLineWrapper = pCommandLineWrapper;
string lSourceLocation = mCommandLineWrapper.RunDirectory;
//Validate source location is not null
if (string.IsNullOrEmpty(lSourceLocation))
{
throw new ExFatalError($"-run argument must be specified");
}
FileInfo lSourceFile = new FileInfo(lSourceLocation);
if (!lSourceFile.Exists)
{
throw new ExFatalError($"Failed to locate source file at {lSourceLocation}");
}
DirectoryInfo sourceFileDirectory = new DirectoryInfo(lSourceLocation);
if (sourceFileDirectory.Exists)
{
mIsBaseDirectoryTemp = false;
mBaseDirectory = sourceFileDirectory;
}
else
{
mIsBaseDirectoryTemp = true;
string tempDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
mBaseDirectory = Directory.CreateDirectory(tempDirectory);
try
{
Logger.logInfo("Extracting archive " + lSourceLocation);
int lFileCount = ArchiveUtil.extractZipToFolder(lSourceFile, mBaseDirectory);
Logger.logInfo("Extracted " + lFileCount + " files");
}
catch (ZipException e)
{
throw new ExInternal($"Zip error extracting zip to {mBaseDirectory.FullName}", e);
}
catch (IOException e)
{
throw new ExInternal($"IO error extracting zip to {mBaseDirectory.FullName}", e);
}
}
Logger.logInfo($"Base directory is {mBaseDirectory.FullName}");
}
//Load image, music, etc
public virtual void prepare(Dictionary <string, int> variables)
{
if (!resourcePath.Equals("~") && resourceStream == null)
{
if (!File.Exists(novelPath + "/" + getType() + "/" + resourcePath))
{
if (!File.Exists(VisualNovel.cacheDirectory + "/" + getType() + "/" + resourcePath))
{
Debug.Log("Couldn't find asset " + resourcePath + " outside of archive, checking " + getType() + ".zip");
if (File.Exists(novelPath + "/" + getType() + ".zip"))
{
using (ZipFile scriptZip = ZipFile.Read(novelPath + "/" + getType() + ".zip")) {
string fileName = resourcePath.Substring(resourcePath.LastIndexOf('/') + 1);
resourcePath = "file://" + ArchiveUtil.extractFromZipFile(scriptZip, fileName, VisualNovel.cacheDirectory);
//
//try {
// scriptZip.ExtractSelectedEntries("name = " + fileName, null, VisualNovel.cacheDirectory);
//} catch (System.Exception e) {
// Debug.Log("Could not find an entry in the " + getType() + " archive for resource " + resourcePath + ". Please ensure this file exists.");
//}
}
}
else
{
Debug.Log("Could not find " + resourcePath + " in folder or archive. Please ensure this file exists.");
resourcePath = "~";
}
}
else
{
resourcePath = "file://" + VisualNovel.cacheDirectory + "/" + getType() + "/" + resourcePath;
}
//This doesn't report accurately?
//if (!File.Exists(resourcePath)) {
// Debug.Log("Was not able to extract the " + getType() + " at " + resourcePath);
//}
}
else
{
resourcePath = "file://" + novelPath + "/" + getType() + "/" + resourcePath;
}
//Now that we've extracted the resource, set up a WWW to load it
resourceStream = new WWW(resourcePath);
}
}
public static async Task <IRecorder> Create(string archiveFile, string workDir)
{
var extractedDirCleanup = DirectoryCleanup.CreateTempDir(workDir, async extractedDir => {
await using (var stream = File.OpenRead(archiveFile)) {
await using var tarStream = new TarInputStream(stream);
await ArchiveUtil.ExtractTar(tarStream, extractedDir);
}
var dependencyMetadata = JsonConvert.DeserializeObject <JObject>(
await File.ReadAllTextAsync(Path.Combine(extractedDir, ArchiveRecorder.TransientMetadataPath))
);
return(new ReplayRecorder(extractedDir, dependencyMetadata));
});
return(await extractedDirCleanup.Value());
}
//--------------------------------------------------------------------------------------------
// 临时版本, 资源拷贝 Resources/ 目录下, 完成之后删除
public bool BuildTempGame(BuildTarget tgt)
{
// 保存路径
string szTgtNm = BuildGameCMD.GetTargetName(tgt);
string szPath = BuildGameCMD.GetBuildFolder(tgt);
string szEx = BuildGameCMD.GetTargetExt(tgt);
string szTitle = "Save " + szTgtNm + " App";
string szApp = szTgtNm + "_" + mGame;
string file = EditorUtility.SaveFilePanel(szTitle, szPath, szApp, szEx);
if (file.Length > 0)
{
//string sPth = "Assets/" + mPath; // 原始资源目录
string dPth = "Assets/Resources/";
//string dfil = "Assets/Resources.meta";
// 若存在则删除
//if (File.Exists(dfil)) FileUtil.DeleteFileOrDirectory(dfil);
//if (Directory.Exists(dPth)) FileUtil.DeleteFileOrDirectory(dPth);
//AssetDatabase.Refresh();
//ArchiveUtil.NtfCopyFiles(sPth, dPth); // 拷贝文件, 内部有过滤
//AssetDatabase.Refresh();
List <string> vAry = ArchiveUtil.NtfGetFiles(dPth, true, "*.unity"); // 搜索场景文件
foreach (string sf in vAry) // 找到启动用场景
{
string ft = sf.ToLower();
//if (ft.Contains("launch"))
if (ft.Contains("demo-summer-a-am"))
{
vAry.Remove(sf);
vAry.Insert(0, sf);
break;
}
}
BuildGameCMD.BuildGamePlayer(file, vAry, tgt, true);
// 结束后删除这些文件
//if (Directory.Exists(dPth)) FileUtil.DeleteFileOrDirectory(dPth);
//if (File.Exists(dfil)) FileUtil.DeleteFileOrDirectory(dfil);
//AssetDatabase.Refresh();
return(true);
}
return(false);
}
//-----------------------------------------------------------------------------
// 找到当前游戏的启动场景 !!!! 这里要按游戏来搜索 !!!!
string FindGameLaunch()
{
string sLaunch = "";
string szPth = Application.dataPath;//GetGamePath();// Application.dataPath;
List <string> vAry = ArchiveUtil.NtfGetFiles(szPth, true, "*.unity");
foreach (string sPth in vAry)
{
string sf = sPth.ToLower();
if (sf.Contains("launch"))
{
sLaunch = sPth;
break;
}
}
//sLaunch = ArchiveUtil.NtfPathAfter(szPth, sLaunch);
sLaunch = ArchiveUtil.NtfPathAfterAssets(sLaunch);
return(sLaunch);
}
//[@MenuItem(@"打包版本/编译三国（简单测试用）")]
//public static void BuildResourcesB()
//{
//}
//[@MenuItem(@"Package/构建场景列表")]
public static void BuildSettingsScene()
{
ArchiveUtil.NtfInitSkips();
ArchiveUtil.AddSkip("NGUI");
ArchiveUtil.AddSkip("Plugins");
List <string> vScn = ArchiveUtil.NtfGetFiles(Application.dataPath, true, "*.unity");
if (vScn.Count > 0)
{
EditorBuildSettingsScene [] scnAry = new EditorBuildSettingsScene[vScn.Count];
for (int i = 0; i < vScn.Count; ++i)
{
scnAry[i] = new EditorBuildSettingsScene(vScn[i], true);
}
EditorBuildSettings.scenes = scnAry;
}
ArchiveUtil.NtfInitSkips();
Debug.Log(@"场景列表构建结束, 共加入 [ " + vScn.Count.ToString() + @" ] 个场景");
}
//--------------------------------------------------------------------------------------------
// 启动
void OnEnable()
{
ArchiveUtil.NtfInitSkips();
PackVerCfg.NtfLoadVerCfg("PackVers/VerConfig.txt");
mVerMng = new VerItemMng();
mVerMng.NtfSearchPackVers(); // 搜索已经存在的版本文件
mTgtCtrl = new UITargetCtrl();
mGameLst = new UIToggleCtrl(@"游戏列表", this.OnClickGameList);
mPubLst = new UIToggleCtrl(@"公共文件"); // 场景列表
mGameRes = new Dictionary <string, GamePackUI>();
mPubLst.EnableHori(true);
mPubLst.LeftTitle(true);
NtfRefreshGames();
NtfRefreshPublic();
mGameLst.AddButton(new BtnItem(101, 40, @"刷新", this.OnClickCtrlBtn));
mPubLst.AddButton(new BtnItem(201, 40, @"刷新", this.OnClickCtrlBtn));
mPubLst.AddButton(new BtnItem(202, 40, @"打包", this.OnClickCtrlBtn));
}
//-----------------------------------------------------------------------------
public static void NtfPackEachFile(string srcFolder, string targetFolder, BuildTarget tgt, bool silence
, GameBundleVersionControl version, PackageVersion.Version cfgVersion)
{
List <string> allNeedPackedFile = ArchiveUtil.NtfGetFiles(srcFolder, true, ArchiveUtil.mSkips);
List <string> procFileList = new List <string>();
string targetPackFile;
foreach (string singleFile in allNeedPackedFile)
{
procFileList.Clear();
procFileList.Add(singleFile);
string[] pathsOfThisFile = singleFile.Split(new char[] { '/', '\\' }, System.StringSplitOptions.RemoveEmptyEntries);
if (pathsOfThisFile.Length < 3)
{
targetPackFile = singleFile.Replace('/', '_');
targetPackFile = targetPackFile.Replace('\\', '_');
targetPackFile = targetFolder + "/" + targetPackFile + ".pack";
}
else
{
targetPackFile = targetFolder + "/";
for (int i = 2; i < pathsOfThisFile.Length; i++)
{
targetPackFile += "_" + pathsOfThisFile[i];
}
targetPackFile += ".pack";
}
targetPackFile = targetPackFile.Replace(" ", "");
targetPackFile = targetPackFile.ToLower();
string packageName = Path.GetFileName(targetPackFile);
packageName = packageName.ToLower();
BuildGameCMD.BuildGamePack(targetPackFile, procFileList, tgt, silence, version);
if (version.m_version.HavePackage(packageName))
{
PackageVersion.Version v = version.m_version.LookupPackageVersion(packageName);
v.m_isExternPackage = cfgVersion.m_isExternPackage;
v.m_isAliveInRuntime = cfgVersion.m_isAliveInRuntime;
version.m_version.AddPackage(packageName, v);
}
}
}
