private void InitGgpk()
{
if (content != null)
{
return;
}
var ggpkPath = textBoxContentGGPK.Text;
if (ggpkPath == String.Empty || !File.Exists(ggpkPath))
{
OutputLine(string.Format("GGPK {0} not exists.", ggpkPath));
return;
}
OutputLine(string.Format("Parsing {0}", ggpkPath));
content = new GrindingGearsPackageContainer();
content.Read(ggpkPath, Output);
_recordsByPath = new Dictionary <string, FileRecord>(content.RecordOffsets.Count);
DirectoryTreeNode.TraverseTreePostorder(
content.DirectoryRoot,
null,
n => _recordsByPath.Add(n.GetDirectoryPath() + n.Name, n));
textBoxContentGGPK.Enabled = false;
buttonSelectPOE.Enabled = false;
//CreateExampleRegistryFile(ggpkPath);
}
static void Main(string[] args)
{
if (args.Length < 3)
{
Console.WriteLine("Usage: ExportGGPK.exe <path to ggpk> <base output dir> <data dir>");
return;
}
contentPath = args[0];
outputPath = args[1];
string data = args[2];
if (!File.Exists(contentPath))
{
Console.WriteLine(string.Format("Content pack file is not available at {0}", contentPath));
return;
}
Container.Read(contentPath, Console.WriteLine);
var gameData = GetDirectory(data);
var dataItems = RecursiveFindByType(gameData);
Console.WriteLine(string.Format("Found {0} data files!", dataItems.Count));
Extract(dataItems);
}
static void Main(string[] args)
{
var ggpkPath = args.Length > 0 ? args[0] : "";
while (!TestPath(ggpkPath))
{
Console.Write("Enter full GGPK name (path + filename) # ");
ggpkPath = Console.ReadLine();
}
var workerThread = new Thread(() =>
{
var content = new GrindingGearsPackageContainer();
try
{
content.Read(ggpkPath, Output);
content.Save(ggpkPath + ".defragmented", Output);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
return;
}
OutputLine("Defragmented GGPK Successfully");
});
workerThread.Start();
}
public void ReloadAllData(string ggpkPath)
{
this.ggpkPath = ggpkPath;
content = new GrindingGearsPackageContainer();
content.Read(ggpkPath, outputFunc);
CollectTranslatableStrings();
MergeUserTranslations();
}
public static void Main(string[] args)
{
// Validate args array size
if (args.Length != 2)
{
Logger.WriteLine("Invalid number of arguments.");
PrintUsage();
return;
}
// Validate arguments
string contentFilePath = args[0];
if (!File.Exists(contentFilePath))
{
Logger.WriteLine($"File '{contentFilePath}' does not exist.");
PrintUsage();
return;
}
string assetOutputDir = args[1];
if (!Directory.Exists(assetOutputDir))
{
Logger.WriteLine($"Directory '{assetOutputDir}' does not exist.");
PrintUsage();
return;
}
try
{
// Read the GGPKG file
GrindingGearsPackageContainer container = new GrindingGearsPackageContainer();
container.Read(contentFilePath, Logger.Write);
/*ExportBaseItemTypeCategories(contentFilePath, assetOutputDir, container);
* ExportBaseItemTypes(contentFilePath, assetOutputDir, container);
* ExportClientStrings(contentFilePath, assetOutputDir, container);
* //maps.json -> Likely created/maintained manually.
* ExportMods(contentFilePath, assetOutputDir, container);*/
ExportStats(contentFilePath, assetOutputDir, container);
//stats-local.json -> Likely/maintained created manually.
//ExportWords(contentFilePath, assetOutputDir, container);
Console.WriteLine(string.Empty);
Console.WriteLine("Press any key to exit...");
Console.Read();
}
catch (Exception ex)
{
PrintError($"{ex.Message}\r\n{ex.StackTrace}");
}
finally
{
Logger.SaveLogs(Path.Combine(assetOutputDir, string.Concat(ApplicationName, ".log")));
}
}
private static void InitGGPK()
{
if (content != null)
{
return;
}
searchContentGGPK();
if (ggpkPaths.Count == 1)
{
ggpkPath = ggpkPaths[0];
}
else if (ggpkPaths.Count > 1)
{
int pos = 0;
foreach (string ggpkPath2 in ggpkPaths)
{
OutputLine(string.Format("[{0}] {1}", pos++, ggpkPath2));
}
OutputLine(string.Format("Choose [0-{0}]: ", pos - 1));
ConsoleKeyInfo cki = Console.ReadKey();
OutputLine("");
Int32 number;
if (Int32.TryParse(cki.KeyChar.ToString(), out number))
{
if (number >= 0 && number <= pos - 1)
{
ggpkPath = ggpkPaths[number];
}
}
}
if (!File.Exists(ggpkPath))
{
OutputLine(string.Format("GGPK {0} not exists.", ggpkPath));
return;
}
OutputLine(string.Format("Parsing {0}", ggpkPath));
content = new GrindingGearsPackageContainer();
content.Read(ggpkPath, Output);
RecordsByPath = new Dictionary <string, FileRecord>(content.RecordOffsets.Count);
DirectoryTreeNode.TraverseTreePostorder(content.DirectoryRoot, null, n => RecordsByPath.Add(n.GetDirectoryPath() + n.Name, n as FileRecord));
}
/// <summary>
/// Reloads the entire content.ggpk, rebuilds the tree
/// </summary>
private void ReloadGgpkFile()
{
TreeView1.Items.Clear();
ResetViewer();
TextBoxOutput.Visibility = Visibility.Visible;
TextBoxOutput.Text = string.Empty;
_content = null;
_workerThread = new Thread(() =>
{
_content = new GrindingGearsPackageContainer();
try
{
_content.Read(_ggpkPath, Output);
}
catch (Exception ex)
{
Output(string.Format(Settings.Strings["ReloadGGPK_Failed"], ex.Message));
return;
}
if (_content.IsReadOnly)
{
Output(Settings.Strings["ReloadGGPK_ReadOnly"] + Environment.NewLine);
UpdateTitle(Settings.Strings["MainWindow_Title_Readonly"]);
}
OutputLine(Settings.Strings["ReloadGGPK_Traversing_Tree"]);
// Collect all FileRecordPath -> FileRecord pairs for easier replacing
_recordsByPath = new Dictionary <string, FileRecord>(_content.RecordOffsets.Count);
DirectoryTreeNode.TraverseTreePostorder(
_content.DirectoryRoot,
null,
n => _recordsByPath.Add(n.GetDirectoryPath() + n.Name, n));
TreeView1.Dispatcher.BeginInvoke(new Action(() =>
{
try
{
var rootItem = CreateLazyTreeViewItem(_content.DirectoryRoot);
TreeView1.Items.Add(rootItem);
rootItem.IsExpanded = true;
rootItem.RaiseEvent(new RoutedEventArgs(TreeViewItem.ExpandedEvent, rootItem));
}
catch (Exception ex)
{
Output(string.Format(Settings.Strings["Error_Read_Directory_Tree"], ex.Message));
Output(ex.StackTrace);
return;
}
_workerThread = null;
}), null);
OutputLine(Settings.Strings["ReloadGGPK_Successful"]);
});
_workerThread.Start();
}