// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "AudioManager.generated.h"
class USoundBase;
class UAudioComponent;
/**
* Game-wide audio manager — BGM playlist + volume control.
*
* Access from anywhere:
* UGameInstance* GI = GetGameInstance(); // or GetWorld()->GetGameInstance()
* UAudioManager* AM = GI->GetSubsystem<UAudioManager>();
*
* BGM asset note:
* USoundBase assets used as BGM tracks must have looping DISABLED so that
* OnAudioFinished fires when the track ends and the playlist advances.
*/
UCLASS()
class UE573PETIT25CL_API UAudioManager : public UGameInstanceSubsystem
{
GENERATED_BODY()
public:
// -------------------------------------------------------
// Playlist
// -------------------------------------------------------
/** BGM tracks to play in order (or randomly when bRandomPlayback is true) */
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="BGM")
TArray<TObjectPtr<USoundBase>> BGMPlaylist;
/**
* If true, tracks are played in a random order.
* A full cycle (every track plays once) is guaranteed before any track repeats.
*/
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="BGM")
bool bRandomPlayback = false;
// -------------------------------------------------------
// Volume (0.0 – 1.0)
// -------------------------------------------------------
/** Overall volume multiplier applied to all audio */
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Volume", meta=(ClampMin=0, ClampMax=1))
float MasterVolume = 1.0f;
/** Volume multiplier applied to BGM on top of MasterVolume */
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Volume", meta=(ClampMin=0, ClampMax=1))
float BGMVolume = 1.0f;
/** Volume multiplier applied to SE on top of MasterVolume */
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Volume", meta=(ClampMin=0, ClampMax=1))
float SEVolume = 1.0f;
public:
// -------------------------------------------------------
// BGM API
// -------------------------------------------------------
/**
* Starts BGM playlist playback.
* @param TrackIndex 0-based index of the first track to play.
* Ignored in random mode — a fresh shuffle is always started.
*/
UFUNCTION(BlueprintCallable, Category="Audio|BGM")
void PlayBGM(int32 TrackIndex = 0);
/** Stops BGM playback and destroys the internal audio component */
UFUNCTION(BlueprintCallable, Category="Audio|BGM")
void StopBGM();
/** Pauses BGM playback */
UFUNCTION(BlueprintCallable, Category="Audio|BGM")
void PauseBGM();
/** Resumes a paused BGM */
UFUNCTION(BlueprintCallable, Category="Audio|BGM")
void ResumeBGM();
/** Skips to the next track immediately */
UFUNCTION(BlueprintCallable, Category="Audio|BGM")
void SkipTrack();
// -------------------------------------------------------
// Volume API
// -------------------------------------------------------
/** Sets the master volume and immediately applies it to the playing BGM */
UFUNCTION(BlueprintCallable, Category="Audio|Volume")
void SetMasterVolume(float Volume);
/** Sets the BGM volume and immediately applies it to the playing BGM */
UFUNCTION(BlueprintCallable, Category="Audio|Volume")
void SetBGMVolume(float Volume);
/** Sets the SE volume (applied to subsequent PlaySE calls) */
UFUNCTION(BlueprintCallable, Category="Audio|Volume")
void SetSEVolume(float Volume);
// -------------------------------------------------------
// SE API
// -------------------------------------------------------
/** Plays a non-spatialized sound effect at MasterVolume * SEVolume */
UFUNCTION(BlueprintCallable, Category="Audio|SE")
void PlaySE2D(USoundBase* Sound);
/** Plays a spatialized sound effect at the given world location at MasterVolume * SEVolume */
UFUNCTION(BlueprintCallable, Category="Audio|SE", meta=(WorldContext="WorldContextObject"))
void PlaySE3D(USoundBase* Sound, const FVector& Location, UObject* WorldContextObject);
private:
/** Currently active BGM audio component */
UPROPERTY()
TObjectPtr<UAudioComponent> BGMComponent;
/** Index of the track that is currently playing */
int32 CurrentTrackIndex = 0;
/** Remaining track indices for random mode; rebuilt when the list is exhausted */
TArray<int32> ShuffledIndices;
/** Plays the track at the given playlist index */
void PlayTrackAtIndex(int32 Index);
/** Called when the current BGM track finishes — advances to the next track */
UFUNCTION()
void OnBGMFinished();
/** Returns the index of the next track to play */
int32 PickNextTrackIndex();
/** Applies the current MasterVolume * BGMVolume to the active audio component */
void RefreshBGMVolume();
/** Fills ShuffledIndices with a fresh Fisher-Yates permutation of all track indices */
void RebuildShuffledIndices();
};
AudioManager.cpp
// Copyright Epic Games, Inc. All Rights Reserved.
#include "AudioManager.h"
#include "Components/AudioComponent.h"
#include "Kismet/GameplayStatics.h"
#include "Sound/SoundBase.h"
// -------------------------------------------------------
// BGM API
// -------------------------------------------------------
void UAudioManager::PlayBGM(int32 TrackIndex)
{
if (BGMPlaylist.IsEmpty())
{
return;
}
// Stop any currently playing track before starting the playlist
StopBGM();
if (bRandomPlayback)
{
// Start a fresh shuffle so every track plays before any repeats
RebuildShuffledIndices();
PlayTrackAtIndex(ShuffledIndices.Pop(EAllowShrinking::No));
}
else
{
PlayTrackAtIndex(FMath::Clamp(TrackIndex, 0, BGMPlaylist.Num() - 1));
}
}
void UAudioManager::StopBGM()
{
if (BGMComponent)
{
// Remove delegate first so Stop() does not accidentally trigger OnBGMFinished
BGMComponent->OnAudioFinished.RemoveDynamic(this, &UAudioManager::OnBGMFinished);
BGMComponent->Stop();
BGMComponent->DestroyComponent();
BGMComponent = nullptr;
}
}
void UAudioManager::PauseBGM()
{
if (BGMComponent)
{
BGMComponent->SetPaused(true);
}
}
void UAudioManager::ResumeBGM()
{
if (BGMComponent)
{
BGMComponent->SetPaused(false);
}
}
void UAudioManager::SkipTrack()
{
if (BGMPlaylist.IsEmpty())
{
return;
}
PlayTrackAtIndex(PickNextTrackIndex());
}
// -------------------------------------------------------
// Volume API
// -------------------------------------------------------
void UAudioManager::SetMasterVolume(float Volume)
{
MasterVolume = FMath::Clamp(Volume, 0.0f, 1.0f);
RefreshBGMVolume();
}
void UAudioManager::SetBGMVolume(float Volume)
{
BGMVolume = FMath::Clamp(Volume, 0.0f, 1.0f);
RefreshBGMVolume();
}
void UAudioManager::SetSEVolume(float Volume)
{
SEVolume = FMath::Clamp(Volume, 0.0f, 1.0f);
}
// -------------------------------------------------------
// SE API
// -------------------------------------------------------
void UAudioManager::PlaySE2D(USoundBase* Sound)
{
if (!Sound)
{
return;
}
UGameplayStatics::SpawnSound2D(GetGameInstance(), Sound, MasterVolume * SEVolume);
}
void UAudioManager::PlaySE3D(USoundBase* Sound, const FVector& Location, UObject* WorldContextObject)
{
if (!Sound || !WorldContextObject)
{
return;
}
UGameplayStatics::SpawnSoundAtLocation(WorldContextObject, Sound, Location,
FRotator::ZeroRotator, MasterVolume * SEVolume);
}
// -------------------------------------------------------
// Private helpers
// -------------------------------------------------------
void UAudioManager::PlayTrackAtIndex(int32 Index)
{
if (!BGMPlaylist.IsValidIndex(Index) || !BGMPlaylist[Index])
{
return;
}
CurrentTrackIndex = Index;
// Tear down previous component and unsubscribe before spawning a new one
if (BGMComponent)
{
BGMComponent->OnAudioFinished.RemoveDynamic(this, &UAudioManager::OnBGMFinished);
BGMComponent->Stop();
BGMComponent->DestroyComponent();
BGMComponent = nullptr;
}
// Spawn a 2D audio component:
// bPersistAcrossLevelTransition = true — BGM survives level loads
// bAutoDestroy = false — we control the lifetime manually
BGMComponent = UGameplayStatics::SpawnSound2D(
GetGameInstance(),
BGMPlaylist[Index],
MasterVolume * BGMVolume,
1.0f, // PitchMultiplier
0.0f, // StartTime
nullptr,// ConcurrencySettings
true, // bPersistAcrossLevelTransition
false // bAutoDestroy
);
if (BGMComponent)
{
BGMComponent->OnAudioFinished.AddDynamic(this, &UAudioManager::OnBGMFinished);
}
}
void UAudioManager::OnBGMFinished()
{
if (BGMPlaylist.IsEmpty())
{
return;
}
PlayTrackAtIndex(PickNextTrackIndex());
}
int32 UAudioManager::PickNextTrackIndex()
{
if (bRandomPlayback)
{
// Rebuild the shuffle pool when every track has been played once
if (ShuffledIndices.IsEmpty())
{
RebuildShuffledIndices();
}
return ShuffledIndices.Pop(EAllowShrinking::No);
}
// Sequential: wrap around to the beginning after the last track
return (CurrentTrackIndex + 1) % BGMPlaylist.Num();
}
void UAudioManager::RefreshBGMVolume()
{
if (BGMComponent)
{
BGMComponent->SetVolumeMultiplier(MasterVolume * BGMVolume);
}
}
void UAudioManager::RebuildShuffledIndices()
{
const int32 Count = BGMPlaylist.Num();
ShuffledIndices.Reset(Count);
for (int32 i = 0; i < Count; ++i)
{
ShuffledIndices.Add(i);
}
// Fisher-Yates shuffle
for (int32 i = Count - 1; i > 0; --i)
{
const int32 j = FMath::RandRange(0, i);
ShuffledIndices.Swap(i, j);
}
}
// Some copyright should be here...
using UnrealBuildTool;
public class furcraHomeAIServerChat2 : ModuleRules
{
public furcraHomeAIServerChat2(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = ModuleRules.PCHUsageMode.UseExplicitOrSharedPCHs;
PublicIncludePaths.AddRange(
new string[] {
// ... add public include paths required here ...
}
);
PrivateIncludePaths.AddRange(
new string[] {
// ... add other private include paths required here ...
}
);
PublicDependencyModuleNames.AddRange(
new string[]
{
"Core", "CoreUObject", "Engine", "UMG","HTTP", "Json", "JsonUtilities"
// ... add other public dependencies that you statically link with here ...
}
);
PrivateDependencyModuleNames.AddRange(
new string[]
{
"CoreUObject",
"Engine",
"Slate",
"SlateCore",
"DeveloperSettings",
// ... add private dependencies that you statically link with here ...
}
);
DynamicallyLoadedModuleNames.AddRange(
new string[]
{
// ... add any modules that your module loads dynamically here ...
}
);
}
}
// Fill out your copyright notice in the Description page of Project Settings.
#include "AiChatTypes.h"
AiChatTypes::AiChatTypes()
{
}
AiChatTypes::~AiChatTypes()
{
}
AiLinkAsyncChat.h
// Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "Kismet/BlueprintAsyncActionBase.h"
#include "AiChatTypes.h"
#include "AiLinkAsyncChat.generated.h"
// Forward declarations for HTTP interfaces to avoid including HTTP headers in this public header
class IHttpRequest;
class IHttpResponse;
using FHttpRequestPtr = TSharedPtr<IHttpRequest, ESPMode::ThreadSafe>;
using FHttpResponsePtr = TSharedPtr<IHttpResponse, ESPMode::ThreadSafe>;
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FAiChatSuccess, const FString&, AssistantText);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FAiChatError, const FString&, Error);
UCLASS()
class FURCRAHOMEAISERVERCHAT2_API UAiLinkAsyncChat : public UBlueprintAsyncActionBase
{
GENERATED_BODY()
public:
UPROPERTY(BlueprintAssignable) FAiChatSuccess OnSuccess;
UPROPERTY(BlueprintAssignable) FAiChatError OnError;
// Messagesは「system + 履歴 + 今回のuser」を含めて渡す
UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true"))
static UAiLinkAsyncChat* SendChat(const TArray<FAiChatMessage>& Messages);
virtual void Activate() override;
private:
TArray<FAiChatMessage> MessagesInternal;
void HandleResponse(FHttpRequestPtr Req, FHttpResponsePtr Resp, bool bOk);
};
// Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
/**
*
*/
class FURCRAHOMEAISERVERCHAT2_API AiLinkRequestTypes
{
public:
AiLinkRequestTypes();
~AiLinkRequestTypes();
};
//#pragma once
//#include "CoreMinimal.h"
#include "AiLinkRequestTypes.generated.h"
USTRUCT()
struct FOllamaGenerateRequest
{
GENERATED_BODY()
UPROPERTY() FString model;
UPROPERTY() FString prompt;
UPROPERTY() bool stream = false;
};
USTRUCT()
struct FOllamaGenerateResponse
{
GENERATED_BODY()
UPROPERTY() FString response;
UPROPERTY() bool done = false;
};
AiLinkRequestTypes.cpp
// Fill out your copyright notice in the Description page of Project Settings.
#include "AiLinkRequestTypes.h"
AiLinkRequestTypes::AiLinkRequestTypes()
{
}
AiLinkRequestTypes::~AiLinkRequestTypes()
{
}
UAiLinkSettings.h
// Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "Engine/DeveloperSettings.h"
#include "UAiLinkSettings.generated.h"
UCLASS(Config = Game, DefaultConfig, meta = (DisplayName = "Home AI Chat"))
class FURCRAHOMEAISERVERCHAT2_API UAiLinkSettings : public UDeveloperSettings
{
GENERATED_BODY()
public:
UPROPERTY(Config, EditAnywhere, Category = "AI")
FString BaseUrl = TEXT("http://192.168.1.23:11434");
UPROPERTY(Config, EditAnywhere, Category = "AI")
//FString Model = TEXT("llama3.1");
//FString Model = TEXT("deepseek-r1:32b");llama3.1:8b
//FString Model = TEXT("llama3.1:70b");//llama3.1:8b
FString Model = TEXT("llama3.1:8b");//
UPROPERTY(Config, EditAnywhere, Category = "AI")
float TimeoutSeconds = 120.0f;
// 例: "You are NPC assistant in my game..."
UPROPERTY(Config, EditAnywhere, Category = "AI")
FString SystemPrompt = TEXT("You are a helpful in-game NPC. Keep replies concise.");
};
UAiLinkSettings.cpp
// Fill out your copyright notice in the Description page of Project Settings.
#include "UAiLinkSettings.h"
Failed to compile plugin source code. See output log for more information.
プラグインのソースコードをコンパイルできませんでした。詳細は出力ログを参照してください。
‘furcraeaUEOpenAI2’ already defines a member called ‘furcraeaUEOpenAI2’ with the same parameter types Expecting to find a type to be declared in a target rules named ‘furcraeaUEOpenAI2EditorTarget’. This type must derive from the ‘TargetRules’ type defined by UnrealBuildTool.
// Copyright Epic Games, Inc. All Rights Reserved.
using UnrealBuildTool;
public class Projects_CustomNode : ModuleRules
{
public Projects_CustomNode(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore","RenderCore" });
PrivateDependencyModuleNames.AddRange(new string[] { });
// Uncomment if you are using Slate UI
// PrivateDependencyModuleNames.AddRange(new string[] { "Slate", "SlateCore" });
// Uncomment if you are using online features
// PrivateDependencyModuleNames.Add("OnlineSubsystem");
// To include OnlineSubsystemSteam, add it to the plugins section in your uproject file with the Enabled attribute set to true
}
}
// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "Modules/ModuleManager.h"
class FProjects_CustomNodeModule : public FDefaultGameModuleImpl
{
public:
virtual void StartupModule() override;
virtual void ShutdownModule() override;
};
# 1 BuildManifest-Windows.txt to Auto Coding
# 1-1 Open Dir \Windows\PatchingDemo\Content\Paks
import os
dir_path = "./Windows/PatchingDemo/Content/Paks/"
files = os.listdir(dir_path)
#print(files)
txtData=""
#minus global Line -2
filelength=len(files)-2
#txtData=txtData+" $NUM_ENTRIES = 9"+"\r\n"
txtData=txtData+"$NUM_ENTRIES = "+str(filelength)+"\r"
txtData=txtData+"$BUILD_ID = PatchingDemoKey"+"\r"
for filename in files:
globalFindNum=filename.find('global')
print("globalFindNum= "+str(globalFindNum))
if(globalFindNum==0):
pass
else:
endNum=filename.find('-')
filenum=filename[8:endNum]
fileSize=os.path.getsize(dir_path+filename)
windowsPath="/Windows/"+filename
#print("filename= "+filename+" fileSize= "+str(fileSize))
tab="\t"
print(tab+filename+tab+str(fileSize)+tab+"ver01"+tab+filenum+tab+windowsPath)
txtData=txtData+filename+tab+str(fileSize)+tab+"ver001"+tab+filenum+tab+windowsPath+"\r"
filePath="./BuildManifest-Windows.txt"
f = open(filePath, 'w', encoding='UTF-8')
f.write(txtData)
f.close()
# 2 copy
起動用バッチファイル
@echo off
set cwdirpath=%~dp0
set pythonpath=D:\Sandbox\python\python-3.12.7\
set codepath=%cwdirpath%\
set pyfile=PatchingDemoKeyAuto_python.py
%pythonpath%python.exe %codepath%%pyfile%
::pause
cmd /k
ブランクなC++プロジェクトにC++フォルダがない状態で、C++ クラスを作る方法 「Tools」プルダウンメニューから「New C++ Class…」を選択します。 ここで新しいクラスを作成できます。
GameInstance
「PatchingDemoGameInstance」を作成
PatchingDemoGameInstance.h
// Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "Engine/GameInstance.h"
#include "PatchingDemoGameInstance.generated.h"
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FPatchCompleteDelegate, bool, Succeeded);
/**
*
*/
UCLASS()
//class UPatchingDemoGameInstance : public UGameInstance
class PATCHINGDEMO_API UPatchingDemoGameInstance :public UGameInstance
{
GENERATED_BODY()
public:
// Overrides
virtual void Init() override;
virtual void Shutdown() override;
UFUNCTION(BlueprintPure, Category = "Patching|Stats")
void GetLoadingProgress(int32& BytesDownloaded, int32& TotalBytesToDownload, float& DownloadPercent, int32& ChunksMounted, int32& TotalChunksToMount, float& MountPercent) const; // Delegates
// Fired when the patching process succeeds or fails
UPROPERTY(BlueprintAssignable, Category = "Patching");
FPatchCompleteDelegate OnPatchComplete;
// Starts the game patching process.Returns false if the patching manifest is not up to date.*/
UFUNCTION(BlueprintCallable, Category = "Patching")
bool PatchGame();
protected:
//Tracks if our local manifest file is up to date with the one hosted on our website
bool bIsDownloadManifestUpToDate;
//Called when the chunk download process finishes
void OnManifestUpdateComplete(bool bSuccess);
// List of Chunk IDs to try and download
UPROPERTY(EditDefaultsOnly, Category = "Patching")
TArray<int32> ChunkDownloadList;
// Called when the chunk download process finishes
void OnDownloadComplete(bool bSuccess);
// Called whenever ChunkDownloader's loading mode is finished
void OnLoadingModeComplete(bool bSuccess);
// Called when ChunkDownloader finishes mounting chunks
void OnMountComplete(bool bSuccess);
};
PatchingDemoGameInstance.cpp
// Fill out your copyright notice in the Description page of Project Settings.
#include "PatchingDemoGameInstance.h"
#include "ChunkDownloader.h"
#include "Misc/CoreDelegates.h"
#include "AssetRegistry/AssetRegistryModule.h"
void UPatchingDemoGameInstance::Init()
{
Super::Init();
const FString DeploymentName = "PatchingDemoLive";
const FString ContentBuildId = "PatchingDemoKey";
// initialize the chunk downloader with chosen platform
TSharedRef<FChunkDownloader> Downloader = FChunkDownloader::GetOrCreate();
Downloader->Initialize("Windows", 8);
// load the cached build ID
Downloader->LoadCachedBuild(DeploymentName);
// update the build manifest file
TFunction<void(bool bSuccess)> UpdateCompleteCallback = [&](bool bSuccess) {bIsDownloadManifestUpToDate = true; };
Downloader->UpdateBuild(DeploymentName, ContentBuildId, UpdateCompleteCallback);
}
void UPatchingDemoGameInstance::Shutdown()
{
Super::Shutdown();
// Shut down ChunkDownloader
FChunkDownloader::Shutdown();
}
void UPatchingDemoGameInstance::OnManifestUpdateComplete(bool bSuccess)
{
bIsDownloadManifestUpToDate = bSuccess;
}
void UPatchingDemoGameInstance::GetLoadingProgress(int32& BytesDownloaded, int32& TotalBytesToDownload, float& DownloadPercent, int32& ChunksMounted, int32& TotalChunksToMount, float& MountPercent) const
{
//Get a reference to ChunkDownloader
TSharedRef<FChunkDownloader> Downloader = FChunkDownloader::GetChecked();
//Get the loading stats struct
FChunkDownloader::FStats LoadingStats = Downloader->GetLoadingStats();
//Get the bytes downloaded and bytes to download
BytesDownloaded = LoadingStats.BytesDownloaded;
TotalBytesToDownload = LoadingStats.TotalBytesToDownload;
//Get the number of chunks mounted and chunks to download
ChunksMounted = LoadingStats.ChunksMounted;
TotalChunksToMount = LoadingStats.TotalChunksToMount;
//Calculate the download and mount percent using the above stats
DownloadPercent = ((float)BytesDownloaded / (float)TotalBytesToDownload) * 100.0f;
MountPercent = ((float)ChunksMounted / (float)TotalChunksToMount) * 100.0f;
}
bool UPatchingDemoGameInstance::PatchGame()
{
// make sure the download manifest is up to date
if (bIsDownloadManifestUpToDate)
{
// get the chunk downloader
TSharedRef<FChunkDownloader> Downloader = FChunkDownloader::GetChecked();
// report current chunk status
for (int32 ChunkID : ChunkDownloadList)
{
int32 ChunkStatus = static_cast<int32>(Downloader->GetChunkStatus(ChunkID));
UE_LOG(LogTemp, Display, TEXT("Chunk %i status:%i"), ChunkID, ChunkStatus);
}
TFunction<void(bool bSuccess)> DownloadCompleteCallback = [&](bool bSuccess) {OnDownloadComplete(bSuccess); };
Downloader->DownloadChunks(ChunkDownloadList, DownloadCompleteCallback, 1);
// start loading mode
TFunction<void(bool bSuccess)> LoadingModeCompleteCallback = [&](bool bSuccess) {OnLoadingModeComplete(bSuccess); };
Downloader->BeginLoadingMode(LoadingModeCompleteCallback);
return true;
}
// you couldn't contact the server to validate your Manifest, so you can't patch
UE_LOG(LogTemp, Display, TEXT("Manifest Update Failed.Can't patch the game"));
return false;
}
void UPatchingDemoGameInstance::OnLoadingModeComplete(bool bSuccess)
{
OnDownloadComplete(bSuccess);
}
void UPatchingDemoGameInstance::OnMountComplete(bool bSuccess)
{
OnPatchComplete.Broadcast(bSuccess);
}
void UPatchingDemoGameInstance::OnDownloadComplete(bool bSuccess)
{
if (bSuccess)
{
UE_LOG(LogTemp, Display, TEXT("Download complete"));
// get the chunk downloader
TSharedRef<FChunkDownloader> Downloader = FChunkDownloader::GetChecked();
FJsonSerializableArrayInt DownloadedChunks;
for (int32 ChunkID : ChunkDownloadList)
{
DownloadedChunks.Add(ChunkID);
}
//Mount the chunks
TFunction<void(bool bSuccess)> MountCompleteCallback = [&](bool bSuccess) {OnMountComplete(bSuccess); };
Downloader->MountChunks(DownloadedChunks, MountCompleteCallback);
OnPatchComplete.Broadcast(true);
}
else
{
UE_LOG(LogTemp, Display, TEXT("Load process failed"));
// call the delegate
OnPatchComplete.Broadcast(false);
}
}
