public void CloseAllWithSave(bool forceZlib = false)
{
for (int i = 0; i < packages.Count; i++)
{
Package pkg = packages[i];
if (mainWindow != null)
{
mainWindow.updateStatusLabel2("Saving package " + (i + 1) + " of " + packages.Count);
}
if (_installer != null)
{
_installer.updateStatusStore("Saving packages " + (i * 100 / packages.Count) + "%");
}
pkg.SaveToFile(forceZlib);
pkg.Dispose();
}
if (GameData.gameType == MeType.ME3_TYPE)
{
TOCBinFile.UpdateAllTOCBinFiles();
}
if (mainWindow != null)
{
mainWindow.updateStatusLabel2("");
}
packages.Clear();
}
private void toolStripMenuItemUpdateTOCs_Click(object sender, EventArgs e)
{
enableGameDataMenu(false);
GameData gameData = new GameData(MeType.ME3_TYPE, _configIni);
if (Directory.Exists(GameData.GamePath))
{
TOCBinFile.UpdateAllTOCBinFiles();
MessageBox.Show("TOC files updated.");
}
else
{
MessageBox.Show("Game path is wrong!");
}
enableGameDataMenu(true);
}
public string removeMipMapsME2ME3(List <FoundTexture> textures, CachePackageMgr cachePackageMgr,
MainWindow mainWindow, Installer installer, bool forceZlib = false)
{
string errors = "";
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
bool modified = false;
if (mainWindow != null)
{
mainWindow.updateStatusLabel("Removing empty mipmaps - package " + (i + 1) + " of " + GameData.packageFiles.Count + " - " + GameData.packageFiles[i]);
mainWindow.updateStatusLabel2("");
}
if (installer != null)
{
installer.updateStatusMipMaps("Removing empty mipmaps " + (i * 100 / GameData.packageFiles.Count) + "%");
}
Package package = null;
try
{
if (cachePackageMgr != null)
{
package = cachePackageMgr.OpenPackage(GameData.packageFiles[i]);
}
else
{
package = new Package(GameData.packageFiles[i], true);
}
}
catch (Exception e)
{
string err = "";
err += "---- Start --------------------------------------------" + Environment.NewLine;
err += "Issue with open package file: " + GameData.packageFiles[i] + Environment.NewLine;
err += e.Message + Environment.NewLine + Environment.NewLine;
err += e.StackTrace + Environment.NewLine + Environment.NewLine;
err += "---- End ----------------------------------------------" + Environment.NewLine + Environment.NewLine;
errors += err;
continue;
}
for (int l = 0; l < package.exportsTable.Count; l++)
{
int id = package.getClassNameId(package.exportsTable[l].classId);
if (id == package.nameIdTexture2D ||
id == package.nameIdTextureFlipBook)
{
using (Texture texture = new Texture(package, l, package.getExportData(l), false))
{
if (!texture.hasImageData() ||
!texture.mipMapsList.Exists(s => s.storageType == Texture.StorageTypes.empty))
{
continue;
}
do
{
texture.mipMapsList.Remove(texture.mipMapsList.First(s => s.storageType == Texture.StorageTypes.empty));
} while (texture.mipMapsList.Exists(s => s.storageType == Texture.StorageTypes.empty));
texture.properties.setIntValue("SizeX", texture.mipMapsList.First().width);
texture.properties.setIntValue("SizeY", texture.mipMapsList.First().height);
texture.properties.setIntValue("MipTailBaseIdx", texture.mipMapsList.Count() - 1);
using (MemoryStream newData = new MemoryStream())
{
newData.WriteFromBuffer(texture.properties.toArray());
newData.WriteFromBuffer(texture.toArray(package.exportsTable[l].dataOffset + (uint)newData.Position));
package.setExportData(l, newData.ToArray());
}
modified = true;
}
}
}
if (cachePackageMgr == null)
{
if (modified)
{
if (package.compressed && package.compressionType != Package.CompressionType.Zlib)
{
package.SaveToFile(forceZlib);
}
else
{
package.SaveToFile();
}
}
package.Dispose();
}
else
{
package.DisposeCache();
}
}
if (GameData.gameType == MeType.ME3_TYPE)
{
TOCBinFile.UpdateAllTOCBinFiles();
}
return(errors);
}
public string PrepareListOfTextures(MeType gameId, TexExplorer texEplorer, MainWindow mainWindow, Installer installer, ref string log, bool ipc)
{
string errors = "";
treeScan = null;
Misc.MD5FileEntry[] md5Entries;
if (gameId == MeType.ME1_TYPE)
{
pkgs = Program.tablePkgsME1;
md5Entries = Program.entriesME1;
}
else if (gameId == MeType.ME2_TYPE)
{
pkgs = Program.tablePkgsME2;
md5Entries = Program.entriesME2;
}
else
{
pkgs = Program.tablePkgsME3;
md5Entries = Program.entriesME3;
}
List <FoundTexture> textures = new List <FoundTexture>();
string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
Assembly.GetExecutingAssembly().GetName().Name);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
string filename = Path.Combine(path, "me" + (int)gameId + "map.bin");
if (mainWindow != null)
{
if (File.Exists(filename))
{
using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.ReadWrite))
{
uint tag = fs.ReadUInt32();
uint version = fs.ReadUInt32();
if (tag != textureMapBinTag || version != textureMapBinVersion)
{
MessageBox.Show("Detected wrong or old version of textures scan file!" +
"\n\nYou need to restore the game to vanilla state then reinstall optional DLC/PCC mods." +
"\n\nThen from the main menu, select 'Remove Textures Scan File' and start Texture Manager again.");
mainWindow.updateStatusLabel("");
mainWindow.updateStatusLabel2("");
texEplorer.Close();
fs.Close();
log += "Detected wrong or old version of textures scan file!" + Environment.NewLine;
log += "You need to restore the game to vanilla state then reinstall optional DLC/PCC mods." + Environment.NewLine;
log += "Then from the main menu, select 'Remove Textures Scan File' and start Texture Manager again." + Environment.NewLine;
return("Detected wrong or old version of textures scan file!" + Environment.NewLine +
"You need to restore the game to vanilla state then reinstall optional DLC/PCC mods." + Environment.NewLine +
"Then from the main menu, select 'Remove Textures Scan File' and start Texture Manager again." + Environment.NewLine);
}
uint countTexture = fs.ReadUInt32();
for (int i = 0; i < countTexture; i++)
{
FoundTexture texture = new FoundTexture();
int len = fs.ReadInt32();
texture.name = fs.ReadStringASCII(len);
texture.crc = fs.ReadUInt32();
uint countPackages = fs.ReadUInt32();
texture.list = new List <MatchedTexture>();
for (int k = 0; k < countPackages; k++)
{
MatchedTexture matched = new MatchedTexture();
matched.exportID = fs.ReadInt32();
matched.linkToMaster = fs.ReadInt32();
len = fs.ReadInt32();
matched.path = fs.ReadStringASCII(len);
texture.list.Add(matched);
}
textures.Add(texture);
}
List <string> packages = new List <string>();
int numPackages = fs.ReadInt32();
for (int i = 0; i < numPackages; i++)
{
int len = fs.ReadInt32();
string pkgPath = fs.ReadStringASCII(len);
pkgPath = GameData.GamePath + pkgPath;
packages.Add(pkgPath);
}
for (int i = 0; i < packages.Count; i++)
{
if (GameData.packageFiles.Find(s => s.Equals(packages[i], StringComparison.OrdinalIgnoreCase)) == null)
{
MessageBox.Show("Detected removal of game files since last game data scan." +
"\n\nYou need to restore the game to vanilla state then reinstall optional DLC/PCC mods." +
"\n\nThen from the main menu, select 'Remove Textures Scan File' and start Texture Manager again.");
return("");
}
}
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
if (packages.Find(s => s.Equals(GameData.packageFiles[i], StringComparison.OrdinalIgnoreCase)) == null)
{
MessageBox.Show("Detected additional game files not present in latest game data scan." +
"\n\nYou need to restore the game to vanilla state then reinstall optional DLC/PCC mods." +
"\n\nThen from the main menu, select 'Remove Textures Scan File' and start Texture Manager again.");
return("");
}
}
treeScan = textures;
mainWindow.updateStatusLabel("");
mainWindow.updateStatusLabel2("");
}
if (!texEplorer.verifyGameDataEmptyMipMapsRemoval())
{
MessageBox.Show("Detected empty mips in game files." +
"\n\nYou need the game in vanilla state and optional DLC/PCC mods." +
"\n\nThen from the main menu, select 'Remove Textures Scan File' and start Texture Manager again.");
return("");
}
return(errors);
}
if (mainWindow != null)
{
List <string> badMods = Misc.detectBrokenMod(GameData.gameType);
if (badMods.Count != 0)
{
errors = "";
for (int l = 0; l < badMods.Count; l++)
{
errors += badMods[l] + Environment.NewLine;
}
MessageBox.Show("Detected not compatible mods: \n\n" + errors);
return("");
}
List <string> mods = Misc.detectMods(GameData.gameType);
if (mods.Count != 0 && GameData.gameType == MeType.ME1_TYPE && GameData.FullScanME1Game)
{
errors = "";
for (int l = 0; l < mods.Count; l++)
{
errors += mods[l] + Environment.NewLine;
}
DialogResult resp = MessageBox.Show("Detected NOT compatible/supported mods with this version of game: \n\n" + errors +
"\n\nPress Cancel to abort or press Ok button to continue.", "Warning !", MessageBoxButtons.OKCancel);
if (resp == DialogResult.Cancel)
{
return("");
}
}
}
DialogResult result = MessageBox.Show("Replacing textures and creating mods requires generating a map of the game's textures.\n" +
"You only need to do it once.\n\n" +
"IMPORTANT! Your game needs to be in vanilla state and have optional DLC/PCC mods installed.\n\n" +
"Are you sure you want to proceed?", "Textures mapping", MessageBoxButtons.YesNo);
if (result == DialogResult.No)
{
texEplorer.Close();
return("");
}
Misc.startTimer();
}
if (!GameData.FullScanME1Game)
{
int count = GameData.packageFiles.Count;
for (int i = 0; i < count; i++)
{
if (GameData.packageFiles[i].Contains("_IT.") ||
GameData.packageFiles[i].Contains("_FR.") ||
GameData.packageFiles[i].Contains("_ES.") ||
GameData.packageFiles[i].Contains("_DE.") ||
GameData.packageFiles[i].Contains("_RA.") ||
GameData.packageFiles[i].Contains("_RU.") ||
GameData.packageFiles[i].Contains("_PLPC.") ||
GameData.packageFiles[i].Contains("_DEU.") ||
GameData.packageFiles[i].Contains("_FRA.") ||
GameData.packageFiles[i].Contains("_ITA.") ||
GameData.packageFiles[i].Contains("_POL."))
{
GameData.packageFiles.Add(GameData.packageFiles[i]);
GameData.packageFiles.RemoveAt(i--);
count--;
}
}
}
if (!generateBuiltinMapFiles && !GameData.FullScanME1Game)
{
List <string> addedFiles = new List <string>();
List <string> modifiedFiles = new List <string>();
loadTexturesMap(gameId, textures);
List <string> sortedFiles = new List <string>();
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
sortedFiles.Add(GameData.RelativeGameData(GameData.packageFiles[i]).ToLowerInvariant());
}
sortedFiles.Sort();
for (int k = 0; k < textures.Count; k++)
{
for (int t = 0; t < textures[k].list.Count; t++)
{
string pkgPath = textures[k].list[t].path.ToLowerInvariant();
if (sortedFiles.BinarySearch(pkgPath) >= 0)
{
continue;
}
MatchedTexture f = textures[k].list[t];
f.path = "";
textures[k].list[t] = f;
}
}
if (installer != null)
{
installer.updateProgressStatus("Scanning packages");
}
if (mainWindow != null)
{
mainWindow.updateStatusLabel("Scanning packages...");
}
if (ipc)
{
Console.WriteLine("[IPC]STAGE_CONTEXT STAGE_SCAN");
Console.Out.Flush();
}
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
int index = -1;
bool modified = true;
bool foundPkg = false;
string package = GameData.RelativeGameData(GameData.packageFiles[i].ToLowerInvariant());
long packageSize = new FileInfo(GameData.packageFiles[i]).Length;
for (int p = 0; p < md5Entries.Length; p++)
{
if (package == md5Entries[p].path.ToLowerInvariant())
{
foundPkg = true;
if (packageSize == md5Entries[p].size)
{
modified = false;
break;
}
index = p;
}
}
if (foundPkg && modified)
{
modifiedFiles.Add(md5Entries[index].path);
}
else if (!foundPkg)
{
addedFiles.Add(GameData.RelativeGameData(GameData.packageFiles[i]));
}
}
int lastProgress = -1;
int totalPackages = modifiedFiles.Count + addedFiles.Count;
int currentPackage = 0;
if (ipc)
{
Console.WriteLine("[IPC]STAGE_WEIGHT STAGE_SCAN " +
string.Format("{0:0.000000}", ((float)totalPackages / GameData.packageFiles.Count)));
Console.Out.Flush();
}
for (int i = 0; i < modifiedFiles.Count; i++, currentPackage++)
{
if (installer != null)
{
installer.updateProgressStatus("Scanning textures " + ((currentPackage + 1) * 100) / totalPackages + "% ");
}
if (mainWindow != null)
{
mainWindow.updateStatusLabel("Finding textures in package " + (currentPackage + 1) + " of " + totalPackages + " - " + modifiedFiles[i]);
}
if (ipc)
{
Console.WriteLine("[IPC]PROCESSING_FILE " + modifiedFiles[i]);
int newProgress = currentPackage * 100 / totalPackages;
if (lastProgress != newProgress)
{
Console.WriteLine("[IPC]TASK_PROGRESS " + newProgress);
lastProgress = newProgress;
}
Console.Out.Flush();
}
errors += FindTextures(gameId, textures, modifiedFiles[i], true, ref log);
}
for (int i = 0; i < addedFiles.Count; i++, currentPackage++)
{
if (installer != null)
{
installer.updateProgressStatus("Scanning textures " + ((currentPackage + 1) * 100) / totalPackages + "% ");
}
if (mainWindow != null)
{
mainWindow.updateStatusLabel("Finding textures in package " + (currentPackage + 1) + " of " + totalPackages + " - " + addedFiles[i]);
}
if (ipc)
{
Console.WriteLine("[IPC]PROCESSING_FILE " + addedFiles[i]);
int newProgress = currentPackage * 100 / totalPackages;
if (lastProgress != newProgress)
{
Console.WriteLine("[IPC]TASK_PROGRESS " + newProgress);
lastProgress = newProgress;
}
Console.Out.Flush();
}
errors += FindTextures(gameId, textures, addedFiles[i], false, ref log);
}
for (int k = 0; k < textures.Count; k++)
{
bool found = false;
for (int t = 0; t < textures[k].list.Count; t++)
{
if (textures[k].list[t].path != "")
{
found = true;
break;
}
}
if (!found)
{
textures[k].list.Clear();
textures.Remove(textures[k]);
k--;
}
}
}
else
{
int lastProgress = -1;
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
if (installer != null)
{
installer.updateProgressStatus("Scanning textures " + ((i + 1) * 100) / GameData.packageFiles.Count + "% ");
}
if (mainWindow != null)
{
mainWindow.updateStatusLabel("Finding textures in package " + (i + 1) + " of " + GameData.packageFiles.Count + " - " + GameData.packageFiles[i]);
}
if (ipc)
{
Console.WriteLine("[IPC]PROCESSING_FILE " + GameData.packageFiles[i]);
int newProgress = i * 100 / GameData.packageFiles.Count;
if (lastProgress != newProgress)
{
Console.WriteLine("[IPC]TASK_PROGRESS " + newProgress);
lastProgress = newProgress;
}
Console.Out.Flush();
}
FindTextures(gameId, textures, GameData.RelativeGameData(GameData.packageFiles[i]), false, ref log);
}
}
if (gameId == MeType.ME1_TYPE)
{
for (int k = 0; k < textures.Count; k++)
{
for (int t = 0; t < textures[k].list.Count; t++)
{
uint mipmapOffset = textures[k].list[t].mipmapOffset;
if (textures[k].list[t].slave)
{
MatchedTexture slaveTexture = textures[k].list[t];
string basePkgName = slaveTexture.basePackageName;
if (basePkgName == Path.GetFileNameWithoutExtension(slaveTexture.path).ToUpperInvariant())
{
throw new Exception();
}
for (int j = 0; j < textures[k].list.Count; j++)
{
if (!textures[k].list[j].slave &&
textures[k].list[j].mipmapOffset == mipmapOffset &&
textures[k].list[j].packageName == basePkgName)
{
slaveTexture.linkToMaster = j;
slaveTexture.slave = true;
textures[k].list[t] = slaveTexture;
break;
}
}
}
}
if (!textures[k].list.Exists(s => s.slave) &&
textures[k].list.Exists(s => s.weakSlave))
{
List <MatchedTexture> texList = new List <MatchedTexture>();
for (int t = 0; t < textures[k].list.Count; t++)
{
MatchedTexture tex = textures[k].list[t];
if (tex.weakSlave)
{
texList.Add(tex);
}
else
{
texList.Insert(0, tex);
}
}
FoundTexture f = textures[k];
f.list = texList;
textures[k] = f;
if (textures[k].list[0].weakSlave)
{
continue;
}
for (int t = 0; t < textures[k].list.Count; t++)
{
if (textures[k].list[t].weakSlave)
{
MatchedTexture slaveTexture = textures[k].list[t];
string basePkgName = slaveTexture.basePackageName;
if (basePkgName == Path.GetFileNameWithoutExtension(slaveTexture.path).ToUpperInvariant())
{
throw new Exception();
}
for (int j = 0; j < textures[k].list.Count; j++)
{
if (!textures[k].list[j].weakSlave &&
textures[k].list[j].packageName == basePkgName)
{
slaveTexture.linkToMaster = j;
slaveTexture.slave = true;
textures[k].list[t] = slaveTexture;
break;
}
}
}
}
}
}
}
if (File.Exists(filename))
{
File.Delete(filename);
}
using (FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
MemoryStream mem = new MemoryStream();
mem.WriteUInt32(textureMapBinTag);
mem.WriteUInt32(textureMapBinVersion);
mem.WriteInt32(textures.Count);
for (int i = 0; i < textures.Count; i++)
{
if (generateBuiltinMapFiles)
{
mem.WriteByte((byte)textures[i].name.Length);
}
else
{
mem.WriteInt32(textures[i].name.Length);
}
mem.WriteStringASCII(textures[i].name);
mem.WriteUInt32(textures[i].crc);
if (generateBuiltinMapFiles)
{
mem.WriteInt16((short)textures[i].width);
mem.WriteInt16((short)textures[i].height);
mem.WriteByte((byte)textures[i].pixfmt);
mem.WriteByte((byte)textures[i].flags);
mem.WriteInt16((short)textures[i].list.Count);
}
else
{
mem.WriteInt32(textures[i].list.Count);
}
for (int k = 0; k < textures[i].list.Count; k++)
{
mem.WriteInt32(textures[i].list[k].exportID);
if (generateBuiltinMapFiles)
{
if (GameData.gameType == MeType.ME1_TYPE)
{
mem.WriteInt16((short)textures[i].list[k].linkToMaster);
if (textures[i].list[k].linkToMaster != -1)
{
mem.WriteStringASCIINull(textures[i].list[k].basePackageName);
}
}
mem.WriteByte(textures[i].list[k].removeEmptyMips ? (byte)1 : (byte)0);
mem.WriteByte((byte)textures[i].list[k].numMips);
mem.WriteInt16((short)pkgs.IndexOf(textures[i].list[k].path));
}
else
{
mem.WriteInt32(textures[i].list[k].linkToMaster);
mem.WriteInt32(textures[i].list[k].path.Length);
mem.WriteStringASCII(textures[i].list[k].path);
}
}
}
if (!generateBuiltinMapFiles)
{
mem.WriteInt32(GameData.packageFiles.Count);
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
string s = GameData.RelativeGameData(GameData.packageFiles[i]);
mem.WriteInt32(s.Length);
mem.WriteStringASCII(s);
}
}
mem.SeekBegin();
if (generateBuiltinMapFiles)
{
fs.WriteUInt32(0x504D5443);
fs.WriteUInt32((uint)mem.Length);
byte[] compressed = new ZlibHelper.Zlib().Compress(mem.ToArray(), 9);
fs.WriteUInt32((uint)compressed.Length);
fs.WriteFromBuffer(compressed);
}
else
{
fs.WriteFromStream(mem, mem.Length);
}
}
if (mainWindow != null)
{
if (!generateBuiltinMapFiles)
{
MipMaps mipmaps = new MipMaps();
if (GameData.gameType == MeType.ME1_TYPE)
{
errors += mipmaps.removeMipMapsME1(1, textures, mainWindow, null, false);
errors += mipmaps.removeMipMapsME1(2, textures, mainWindow, null, false);
}
else
{
errors += mipmaps.removeMipMapsME2ME3(textures, mainWindow, null, false, false);
}
if (GameData.gameType == MeType.ME3_TYPE)
{
TOCBinFile.UpdateAllTOCBinFiles();
}
}
}
treeScan = textures;
if (mainWindow != null)
{
var time = Misc.stopTimer();
mainWindow.updateStatusLabel("Done. Process total time: " + Misc.getTimerFormat(time));
mainWindow.updateStatusLabel2("");
}
return(errors);
}
public void repackME23(MeType gameId)
{
string errors = "";
GameData gameData = new GameData(gameId, _configIni);
if (!Directory.Exists(GameData.GamePath))
{
MessageBox.Show("Game path is wrong!");
return;
}
GetPackages(gameData);
string path = "";
if (gameId == MeType.ME2_TYPE)
{
path = @"\BioGame\CookedPC\BIOC_Materials.pcc".ToLowerInvariant();
}
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
if (path != "" && GameData.packageFiles[i].ToLowerInvariant().Contains(path))
{
continue;
}
updateStatusLabel("Repack PCC file " + (i + 1) + " of " + GameData.packageFiles.Count);
try
{
Package package = new Package(GameData.packageFiles[i], true);
if (!package.compressed || package.compressed && package.compressionType != Package.CompressionType.Zlib)
{
package.Dispose();
package = new Package(GameData.packageFiles[i]);
package.SaveToFile(true, false, false);
}
package.Dispose();
}
catch (Exception e)
{
if (e.Message.Contains("Problem with PCC file header:"))
{
continue;
}
errors += "The file is propably broken, skipped: " + GameData.packageFiles[i] + Environment.NewLine;
}
}
TOCBinFile.UpdateAllTOCBinFiles();
if (errors != "")
{
string filename = "pcc-errors.txt";
if (File.Exists(filename))
{
File.Delete(filename);
}
using (FileStream fs = new FileStream(filename, FileMode.CreateNew))
{
fs.WriteStringASCII(errors);
}
MessageBox.Show("WARNING: Some errors have occured!");
Process.Start(filename);
}
updateStatusLabel("Done");
updateStatusLabel2("");
}
private void PackAllME3DLC()
{
GameData gameData = new GameData(MeType.ME3_TYPE, _configIni);
if (!Directory.Exists(GameData.GamePath))
{
MessageBox.Show("Game path is wrong!");
return;
}
if (!Directory.Exists(GameData.DLCData))
{
MessageBox.Show("No DLCs need to be compressed.");
return;
}
List <string> dlcs = Directory.GetFiles(GameData.DLCData, "Mount.dlc", SearchOption.AllDirectories).ToList();
if (dlcs.Count() == 0)
{
MessageBox.Show("No DLCs need to be compressed.");
return;
}
Misc.startTimer();
TOCBinFile.UpdateAllTOCBinFiles();
List <string> DLCs = Directory.GetDirectories(GameData.DLCData).ToList();
for (int i = 0; i < DLCs.Count; i++)
{
List <string> files = Directory.GetFiles(DLCs[i], "Mount.dlc", SearchOption.AllDirectories).ToList();
if (files.Count == 0)
{
DLCs.RemoveAt(i--);
}
}
long diskFreeSpace = Misc.getDiskFreeSpace(GameData.GamePath);
long diskUsage = 0;
for (int i = 0; i < DLCs.Count; i++)
{
diskUsage += Misc.getDirectorySize(DLCs[i]);
}
diskUsage = (long)(diskUsage / 1.9);
if (diskUsage < diskFreeSpace)
{
for (int i = 0; i < DLCs.Count; i++)
{
string DLCname = Path.GetFileName(DLCs[i]);
updateStatusLabel("DLC compressing - " + (i + 1) + " of " + DLCs.Count);
PackME3DLC(DLCs[i], DLCname);
}
string tmpDlcDir = Path.Combine(GameData.GamePath, "BIOGame", "DLCTemp");
string originInstallFiles = Path.Combine(GameData.DLCData, "__metadata");
if (Directory.Exists(originInstallFiles))
{
Directory.Move(originInstallFiles, tmpDlcDir + "\\__metadata");
}
DLCs = Directory.GetFiles(GameData.DLCData, "Default.sfar", SearchOption.AllDirectories).ToList();
for (int i = 0; i < DLCs.Count; i++)
{
if (!File.Exists(Path.Combine(Path.GetDirectoryName(DLCs[i]), "Mount.dlc")))
{
string source = Path.GetDirectoryName(Path.GetDirectoryName(DLCs[i]));
Directory.Move(source, tmpDlcDir + "\\" + Path.GetFileName(source));
}
}
Directory.Delete(GameData.DLCData, true);
Directory.Move(tmpDlcDir, GameData.DLCData);
var time = Misc.stopTimer();
updateStatusLabel("DLCs repacked. Process total time: " + Misc.getTimerFormat(time));
updateStatusLabel2("");
}
else
{
MessageBox.Show("You have not enough disk space remaining. You need about " + Misc.getBytesFormat(diskUsage) + " free.");
}
updateStatusLabel2("");
}
private void buttonSTART_Click(object sender, EventArgs e)
{
buttonsEnable(false);
buttonPreInstallCheck.Enabled = false;
buttonSTART.Enabled = false;
labelFinalStatus.Text = "Process in progress...";
errors = "";
log = "";
Misc.startTimer();
log += "Prepare game data started..." + Environment.NewLine;
updateStatusPrepare("In progress...");
if (GameData.gameType == MeType.ME1_TYPE)
{
Misc.VerifyME1Exe(gameData, false);
}
if (GameData.gameType == MeType.ME3_TYPE)
{
ME3DLC.unpackAllDLC(null, this);
gameData.getPackages(true, true);
}
if (GameData.gameType != MeType.ME1_TYPE)
{
gameData.getTfcTextures();
}
checkBoxPrepare.Checked = true;
updateStatusPrepare("");
log += "Prepare game data finished" + Environment.NewLine + Environment.NewLine;
if (Directory.Exists(GameData.DLCData))
{
List <string> dirs = Directory.EnumerateDirectories(GameData.DLCData).ToList();
log += "Detected folowing folders in DLC path:" + Environment.NewLine;
for (int dl = 0; dl < dirs.Count; dl++)
{
log += Path.GetFileName(dirs[dl]) + Environment.NewLine;
}
}
else
{
log += "Not detected folders in DLC path" + Environment.NewLine;
}
log += Environment.NewLine;
log += "Scan textures started..." + Environment.NewLine;
updateStatusScan("In progress...");
if (checkBoxOptionFaster.Checked)
{
errors += treeScan.PrepareListOfTextures(null, cachePackageMgr, null, this, ref log, true);
}
else
{
errors += treeScan.PrepareListOfTextures(null, null, null, this, ref log, true);
}
textures = treeScan.treeScan;
checkBoxScan.Checked = true;
updateStatusScan("");
log += "Scan textures finished" + Environment.NewLine + Environment.NewLine;
if (checkBoxOptionFaster.Checked)
{
if (GameData.gameType == MeType.ME1_TYPE)
{
log += "Remove mipmaps started..." + Environment.NewLine;
updateStatusMipMaps("In progress...");
errors += mipMaps.removeMipMapsME1(1, textures, cachePackageMgr, null, this, checkBoxPreEnableRepack.Checked);
errors += mipMaps.removeMipMapsME1(2, textures, cachePackageMgr, null, this, checkBoxPreEnableRepack.Checked);
checkBoxMipMaps.Checked = true;
updateStatusMipMaps("");
log += "Remove mipmaps finished" + Environment.NewLine + Environment.NewLine;
}
else
{
log += "Remove mipmaps started..." + Environment.NewLine;
updateStatusMipMaps("In progress...");
errors += mipMaps.removeMipMapsME2ME3(textures, cachePackageMgr, null, this, checkBoxPreEnableRepack.Checked);
checkBoxMipMaps.Checked = true;
updateStatusMipMaps("");
log += "Remove mipmaps finished" + Environment.NewLine + Environment.NewLine;
}
}
log += "Process textures started..." + Environment.NewLine;
updateStatusTextures("In progress...");
applyModules();
checkBoxTextures.Checked = true;
updateStatusTextures("");
log += "Process textures finished" + Environment.NewLine + Environment.NewLine;
updateStatusStore("Progress...");
cachePackageMgr.CloseAllWithSave(checkBoxPreEnableRepack.Checked);
checkBoxStore.Checked = true;
updateStatusStore("");
if (!checkBoxOptionFaster.Checked)
{
if (GameData.gameType == MeType.ME1_TYPE)
{
log += "Remove mipmaps started..." + Environment.NewLine;
updateStatusMipMaps("In progress...");
errors += mipMaps.removeMipMapsME1(1, textures, null, null, this, checkBoxPreEnableRepack.Checked);
errors += mipMaps.removeMipMapsME1(2, textures, null, null, this, checkBoxPreEnableRepack.Checked);
checkBoxMipMaps.Checked = true;
updateStatusMipMaps("");
log += "Remove mipmaps finished" + Environment.NewLine + Environment.NewLine;
}
else
{
log += "Remove mipmaps started..." + Environment.NewLine;
updateStatusMipMaps("In progress...");
errors += mipMaps.removeMipMapsME2ME3(textures, null, null, this, checkBoxPreEnableRepack.Checked);
checkBoxMipMaps.Checked = true;
updateStatusMipMaps("");
log += "Remove mipmaps finished" + Environment.NewLine + Environment.NewLine;
}
}
log += "Updating LODs and other settings started..." + Environment.NewLine;
updateStatusLOD("In progress...");
string path = gameData.EngineConfigIniPath;
bool exist = File.Exists(path);
if (!exist)
{
Directory.CreateDirectory(Path.GetDirectoryName(path));
}
ConfIni engineConf = new ConfIni(path);
LODSettings.updateLOD((MeType)gameId, engineConf);
LODSettings.updateGFXSettings((MeType)gameId, engineConf);
checkBoxLOD.Checked = true;
updateStatusLOD("");
log += "Updating LODs and other settings finished" + Environment.NewLine + Environment.NewLine;
if (checkBoxPreEnableRepack.Checked)
{
log += "Repack started..." + Environment.NewLine;
for (int i = 0; i < GameData.packageFiles.Count; i++)
{
updateStatusRepackZlib("Repacking PCC files... " + ((i + 1) * 100 / GameData.packageFiles.Count) + " %");
Package package = new Package(GameData.packageFiles[i], true, true);
if (package.compressed && package.compressionType != Package.CompressionType.Zlib)
{
package.Dispose();
package = new Package(GameData.packageFiles[i]);
package.SaveToFile(true);
}
}
checkBoxRepackZlib.Checked = true;
updateStatusRepackZlib("");
log += "Repack finished" + Environment.NewLine + Environment.NewLine;
}
if (checkBoxPreEnablePack.Checked)
{
if (Directory.Exists(GameData.DLCData))
{
TOCBinFile.UpdateAllTOCBinFiles();
log += "Repack started..." + Environment.NewLine;
updateStatusPackDLC("In progress...");
List <string> DLCs = Directory.GetDirectories(GameData.DLCData).ToList();
for (int i = 0; i < DLCs.Count; i++)
{
List <string> files = Directory.GetFiles(DLCs[i], "Mount.dlc", SearchOption.AllDirectories).ToList();
if (files.Count == 0)
{
DLCs.RemoveAt(i--);
}
}
string tmpDlcDir = Path.Combine(GameData.GamePath, "BIOGame", "DLCTemp");
for (int i = 0; i < DLCs.Count; i++)
{
string DLCname = Path.GetFileName(DLCs[i]);
string outPath = Path.Combine(tmpDlcDir, DLCname, "CookedPCConsole", "Default.sfar");
ME3DLC dlc = new ME3DLC(null);
dlc.fullRePack(DLCs[i], outPath, DLCname, null, this);
}
Directory.Delete(GameData.DLCData, true);
Directory.Move(tmpDlcDir, GameData.DLCData);
updateStatusPackDLC("");
log += "Repack started finished" + Environment.NewLine + Environment.NewLine;
}
checkBoxPackDLC.Checked = true;
}
var time = Misc.stopTimer();
labelFinalStatus.Text = "Process finished. Process total time: " + Misc.getTimerFormat(time);
buttonExit.Enabled = true;
buttonNormal.Enabled = true;
log += "==========================================" + Environment.NewLine;
log += "LOD settings:" + Environment.NewLine;
LODSettings.readLOD((MeType)gameId, engineConf, ref log);
log += "==========================================" + Environment.NewLine;
string filename = "install-log.txt";
if (File.Exists(filename))
{
File.Delete(filename);
}
using (FileStream fs = new FileStream(filename, FileMode.CreateNew))
{
fs.WriteStringASCII(log);
}
filename = "errors-install.txt";
if (File.Exists(filename))
{
File.Delete(filename);
}
if (errors != "")
{
using (FileStream fs = new FileStream(filename, FileMode.CreateNew))
{
fs.WriteStringASCII(errors);
}
MessageBox.Show("WARNING: Some errors have occured!");
Process.Start(filename);
}
}