How Can We Help?
Unzip multiple files
Overview
The Unzip Files function extracts all files from a ZIP archive immediately and returns the list of extracted file paths. This is the simplest extraction operation in Archive Manager Pro, perfect for quick file extraction tasks where blocking execution is acceptable.
Function Description
Node Name: Unzip Files
Category: Archive Manager
Type: Synchronous (blocking operation)
Extracts all files from a ZIP archive and returns an array containing the full paths to all extracted files. The operation completes immediately and execution blocks until all files are extracted.
Blueprint Usage
Input Parameters
Parameter | Type | Description |
---|---|---|
Path to Zip | String | Full absolute path to the ZIP file you want to extract |
Delete After Extraction | Boolean | If true, deletes the ZIP file after successful extraction |
Output Parameters
Parameter | Type | Description |
---|---|---|
Path to Files | Array of Strings | Array containing full paths to all extracted files |
Return Value | Boolean | true if extraction succeeded, false if it failed |
Blueprint Setup Steps
- Add the Unzip Files Node
- Right-click in the Event Graph → Search for “Unzip Files”
- Add the Unzip Files node from the Archive Manager category
- Configure Input
- Path to Zip:
F:\Repos\tests\ArchiveManager\twofiles.zip
- Delete After Extraction: ☐ Unchecked (keep original ZIP file)
- Path to Zip:
- Process Extracted Files
- Connect Path to Files array to a For Each Loop node
- Connect Array Element to Print String to display each file path
- Connect Completed output to final status message
- Handle Success/Failure
- Optionally check Return Value for success confirmation
- Use Get Last Archive Error if extraction fails
Example Blueprint Setup

C++ Usage
Basic Implementation
#include "ArchiveManagerBPLibrary.h"
// Synchronous extraction
FString ZipPath = TEXT("C:/Archives/DocumentBundle.zip");
TArray<FString> ExtractedFiles;
bool DeleteZipAfter = false;
bool Success = UArchiveManagerBPLibrary::UnzipFiles(ZipPath, ExtractedFiles, DeleteZipAfter);
if (Success)
{
UE_LOG(LogTemp, Log, TEXT("Successfully extracted %d files:"), ExtractedFiles.Num());
// Process each extracted file
for (const FString& FilePath : ExtractedFiles)
{
UE_LOG(LogTemp, Log, TEXT(" - %s"), *FilePath);
ProcessExtractedFile(FilePath);
}
}
else
{
FString Error = UArchiveManagerBPLibrary::GetLastArchiveError();
UE_LOG(LogTemp, Error, TEXT("Extraction failed: %s"), *Error);
}
Advanced File Processing
class MYGAME_API FFileExtractor
{
public:
// Extract and categorize files by type
static bool ExtractAndCategorizeFiles(const FString& ZipPath, TMap<FString, TArray<FString>>& CategorizedFiles)
{
TArray<FString> ExtractedFiles;
bool bSuccess = UArchiveManagerBPLibrary::UnzipFiles(ZipPath, ExtractedFiles, false);
if (!bSuccess)
{
UE_LOG(LogTemp, Error, TEXT("Failed to extract archive: %s"), *ZipPath);
return false;
}
// Categorize files by extension
for (const FString& FilePath : ExtractedFiles)
{
FString Extension = FPaths::GetExtension(FilePath).ToLower();
if (!CategorizedFiles.Contains(Extension))
{
CategorizedFiles.Add(Extension, TArray<FString>());
}
CategorizedFiles[Extension].Add(FilePath);
}
// Log categorization results
for (const auto& Category : CategorizedFiles)
{
UE_LOG(LogTemp, Log, TEXT("Found %d files with extension '%s'"),
Category.Value.Num(), *Category.Key);
}
return true;
}
// Extract with file validation
static TArray<FString> ExtractWithValidation(const FString& ZipPath, const TArray<FString>& ExpectedFiles)
{
TArray<FString> ExtractedFiles;
TArray<FString> ValidatedFiles;
bool bSuccess = UArchiveManagerBPLibrary::UnzipFiles(ZipPath, ExtractedFiles, false);
if (!bSuccess)
{
UE_LOG(LogTemp, Error, TEXT("Extraction failed"));
return ValidatedFiles;
}
// Validate extracted files against expected list
for (const FString& ExpectedFile : ExpectedFiles)
{
bool bFound = false;
for (const FString& ExtractedFile : ExtractedFiles)
{
if (FPaths::GetCleanFilename(ExtractedFile) == ExpectedFile)
{
ValidatedFiles.Add(ExtractedFile);
bFound = true;
break;
}
}
if (!bFound)
{
UE_LOG(LogTemp, Warning, TEXT("Expected file not found: %s"), *ExpectedFile);
}
}
UE_LOG(LogTemp, Log, TEXT("Validated %d of %d expected files"),
ValidatedFiles.Num(), ExpectedFiles.Num());
return ValidatedFiles;
}
// Extract to specific directory
static bool ExtractToDirectory(const FString& ZipPath, const FString& TargetDirectory)
{
// Note: The plugin extracts to the same directory as the ZIP file by default
// This function moves files to a target directory after extraction
TArray<FString> ExtractedFiles;
bool bSuccess = UArchiveManagerBPLibrary::UnzipFiles(ZipPath, ExtractedFiles, false);
if (!bSuccess)
{
return false;
}
// Ensure target directory exists
if (!FPaths::DirectoryExists(TargetDirectory))
{
IFileManager::Get().MakeDirectory(*TargetDirectory, true);
}
// Move extracted files to target directory
TArray<FString> MovedFiles;
for (const FString& SourcePath : ExtractedFiles)
{
FString FileName = FPaths::GetCleanFilename(SourcePath);
FString TargetPath = TargetDirectory / FileName;
if (IFileManager::Get().Move(*TargetPath, *SourcePath))
{
MovedFiles.Add(TargetPath);
UE_LOG(LogTemp, Log, TEXT("Moved: %s -> %s"), *SourcePath, *TargetPath);
}
else
{
UE_LOG(LogTemp, Error, TEXT("Failed to move: %s"), *SourcePath);
}
}
UE_LOG(LogTemp, Log, TEXT("Successfully moved %d files to %s"),
MovedFiles.Num(), *TargetDirectory);
return MovedFiles.Num() == ExtractedFiles.Num();
}
};
Game Asset Loading System
UCLASS(BlueprintType)
class MYGAME_API UAssetPackageLoader : public UObject
{
GENERATED_BODY()
public:
// Load game asset package from ZIP
UFUNCTION(BlueprintCallable, Category = "Asset Loading")
bool LoadAssetPackage(const FString& PackageZipPath, FAssetPackageInfo& PackageInfo)
{
TArray<FString> ExtractedFiles;
bool bSuccess = UArchiveManagerBPLibrary::UnzipFiles(PackageZipPath, ExtractedFiles, false);
if (!bSuccess)
{
UE_LOG(LogTemp, Error, TEXT("Failed to extract asset package: %s"), *PackageZipPath);
return false;
}
// Process extracted files
PackageInfo.PackageName = FPaths::GetBaseFilename(PackageZipPath);
PackageInfo.ExtractedFiles = ExtractedFiles;
for (const FString& FilePath : ExtractedFiles)
{
FString Extension = FPaths::GetExtension(FilePath).ToLower();
if (Extension == TEXT("uasset"))
{
PackageInfo.AssetFiles.Add(FilePath);
}
else if (Extension == TEXT("umap"))
{
PackageInfo.MapFiles.Add(FilePath);
}
else if (Extension == TEXT("json"))
{
// Load package metadata
LoadPackageMetadata(FilePath, PackageInfo);
}
else if (Extension == TEXT("png") || Extension == TEXT("jpg"))
{
PackageInfo.TextureFiles.Add(FilePath);
}
}
UE_LOG(LogTemp, Log, TEXT("Loaded package '%s': %d assets, %d maps, %d textures"),
*PackageInfo.PackageName,
PackageInfo.AssetFiles.Num(),
PackageInfo.MapFiles.Num(),
PackageInfo.TextureFiles.Num());
// Register package with asset manager
RegisterAssetPackage(PackageInfo);
return true;
}
// Batch process multiple packages
UFUNCTION(BlueprintCallable, Category = "Asset Loading")
int32 LoadMultiplePackages(const TArray<FString>& PackageZipPaths)
{
int32 SuccessCount = 0;
for (const FString& ZipPath : PackageZipPaths)
{
FAssetPackageInfo PackageInfo;
if (LoadAssetPackage(ZipPath, PackageInfo))
{
SuccessCount++;
}
}
UE_LOG(LogTemp, Log, TEXT("Successfully loaded %d of %d packages"),
SuccessCount, PackageZipPaths.Num());
return SuccessCount;
}
private:
void LoadPackageMetadata(const FString& JsonPath, FAssetPackageInfo& PackageInfo) { /* Implementation */ }
void RegisterAssetPackage(const FAssetPackageInfo& PackageInfo) { /* Implementation */ }
};
// Supporting structure
USTRUCT(BlueprintType)
struct FAssetPackageInfo
{
GENERATED_BODY()
UPROPERTY(BlueprintReadOnly)
FString PackageName;
UPROPERTY(BlueprintReadOnly)
TArray<FString> ExtractedFiles;
UPROPERTY(BlueprintReadOnly)
TArray<FString> AssetFiles;
UPROPERTY(BlueprintReadOnly)
TArray<FString> MapFiles;
UPROPERTY(BlueprintReadOnly)
TArray<FString> TextureFiles;
UPROPERTY(BlueprintReadOnly)
FString Version;
UPROPERTY(BlueprintReadOnly)
FString Description;
};
Simple Utility Functions
// Quick extraction utility
TArray<FString> QuickExtract(const FString& ZipPath)
{
TArray<FString> ExtractedFiles;
UArchiveManagerBPLibrary::UnzipFiles(ZipPath, ExtractedFiles, false);
return ExtractedFiles;
}
// Check what's inside a ZIP without extracting
bool PreviewZipContents(const FString& ZipPath, TArray<FString>& FileList)
{
// Note: This would require additional implementation to read ZIP directory
// For now, we extract to get the file list
TArray<FString> ExtractedFiles;
bool bSuccess = UArchiveManagerBPLibrary::UnzipFiles(ZipPath, ExtractedFiles, false);
if (bSuccess)
{
// Convert full paths to just filenames for preview
for (const FString& FullPath : ExtractedFiles)
{
FileList.Add(FPaths::GetCleanFilename(FullPath));
}
}
return bSuccess;
}
// Extract and count files by type
void AnalyzeExtractedFiles(const FString& ZipPath)
{
TArray<FString> ExtractedFiles;
bool bSuccess = UArchiveManagerBPLibrary::UnzipFiles(ZipPath, ExtractedFiles, false);
if (bSuccess)
{
TMap<FString, int32> ExtensionCounts;
for (const FString& FilePath : ExtractedFiles)
{
FString Extension = FPaths::GetExtension(FilePath).ToLower();
ExtensionCounts.FindOrAdd(Extension)++;
}
UE_LOG(LogTemp, Log, TEXT("Extracted %d files from %s:"), ExtractedFiles.Num(), *ZipPath);
for (const auto& Pair : ExtensionCounts)
{
UE_LOG(LogTemp, Log, TEXT(" %s: %d files"), *Pair.Key, Pair.Value);
}
}
}
Common Use Cases
Game Development
- Asset Package Loading: Extract game content packages
- Save Game Import: Extract backup save files
- Configuration Loading: Extract settings and configuration files
- Resource Bundles: Extract localization or texture packages
Application Development
- Data Import: Extract CSV, JSON, or XML data files
- Document Processing: Extract document bundles for processing
- Template Extraction: Extract project templates or themes
- Backup Restoration: Extract backed-up application data
Best Practices
Performance Considerations
- Use for small to medium archives (< 50MB, < 100 files)
- Consider async version for larger archives or UI responsiveness
- Process files incrementally in the For Each Loop
- Clean up extracted files when no longer needed
Error Handling
- Always check Return Value before processing files
- Validate ZIP file exists before extraction
- Handle insufficient disk space gracefully
- Use Get Last Archive Error for specific error information
File Management
- Validate extracted file paths before processing
- Check file permissions on extracted files
- Handle duplicate filenames appropriately
- Monitor disk space during extraction
Extraction Behavior
- Extraction Location: Files are extracted to the same directory as the ZIP file
- Filename Preservation: Original filenames and extensions are preserved
- Directory Structure: Flattened – subdirectories in ZIP become part of filename
- Overwrite Behavior: Existing files with same names are overwritten
Performance Notes
- Synchronous operation: Blocks execution until all files are extracted
- Memory usage: Moderate – files are extracted to disk, not loaded into memory
- File I/O: Sequential file extraction, optimized for reliability over speed
- Thread safety: Safe to call from main thread, but will block UI updates