Ange/DTFluxAPI
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixing Various Bugs On Delegates

Browse Source
This commit is contained in:
Ange-Marie MAURIN
2025-07-11 19:04:37 +02:00
parent 73413e44b4
commit f1f300a351
12 changed files with 2765 additions and 1207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

189
Source/DTFluxCoreSubsystem/Private/DTFluxCoreSubsystem.cpp
View File

@ -84,9 +84,6 @@ void UDTFluxCoreSubsystem::RegisterDelegates()
&UDTFluxCoreSubsystem::ProcessSplitRanking
);
// ⚠️ ATTENTION : Vous avez un doublon ici !
// NetworkSubsystem->OnReceivedTeamUpdate().BindUFunction(this, "ProcessTeamList");
NetworkSubsystem->OnReceivedTeamStatusUpdate().BindUObject(
this,
&UDTFluxCoreSubsystem::ProcessTeamStatusUpdate
@ -205,6 +202,173 @@ void UDTFluxCoreSubsystem::SendRequest(const FString& Message)
}
}
bool UDTFluxCoreSubsystem::GetContestRankings(const int ContestId,
FDTFluxContestRankings& OutContestRankings)
{
if (DataStorage->ContestRankings.Contains(ContestId))
{
OutContestRankings = DataStorage->ContestRankings[ContestId];
return true;
}
if (NetworkSubsystem)
{
TArray<int> TackedContestIds = {ContestId};
TrackedRequestContestRankings(TackedContestIds);
return false;
}
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("NetworkSubsystem unavailable"));
return false;
}
bool UDTFluxCoreSubsystem::GetStageRankings(const int ContestId, const int StageId,
FDTFluxStageRankings& OutStageRankings)
{
return GetStageRankingsWithKey(FDTFluxStageKey(ContestId, StageId), OutStageRankings);
}
bool UDTFluxCoreSubsystem::GetSplitRankings(const int ContestId, const int StageId, const int SplitId,
FDTFluxSplitRankings& OutSplitRankings)
{
return GetSplitRankingsWithKey(FDTFluxSplitKey(ContestId, StageId, SplitId), OutSplitRankings);
}
bool UDTFluxCoreSubsystem::GetStageRankingsWithKey(const FDTFluxStageKey StageKey,
FDTFluxStageRankings& OutStageRankings, const bool bShouldUseCached)
{
//We Have the data
if (DataStorage->StageRankings.Contains(StageKey) && bShouldUseCached)
{
OutStageRankings = DataStorage->StageRankings[StageKey];
return true;
}
else
{
if (NetworkSubsystem)
{
TArray<FDTFluxStageKey> TackedStageKeys = {StageKey};
TrackedRequestStageRankings(TackedStageKeys);
OutStageRankings = FDTFluxStageRankings();
return false;
}
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("NetworkSubsystem unavailable"))
}
return false;
}
bool UDTFluxCoreSubsystem::GetSplitRankingsWithKey(const FDTFluxSplitKey SplitKey,
FDTFluxSplitRankings& OutSplitRankings, const bool bShouldUseCached)
{
//We Have the data
if (DataStorage->SplitRankings.Contains(SplitKey) && bShouldUseCached)
{
OutSplitRankings = DataStorage->SplitRankings[SplitKey];
return true;
}
else
{
if (NetworkSubsystem)
{
TArray<FDTFluxSplitKey> TackedSplitKey = {SplitKey};
TrackedRequestSplitRankings(TackedSplitKey);
OutSplitRankings = FDTFluxSplitRankings();
return false;
}
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("NetworkSubsystem unavailable"))
return false;
}
}
TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestContestRankings(const TArray<int> ForContests)
{
if (NetworkSubsystem)
{
TArray<FGuid> RequestIds;
FOnDTFluxRequestSuccess OnSuccess = FOnDTFluxRequestSuccess::CreateLambda(
[this](const FDTFluxTrackedRequest& Request)
{
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("ContestRanking Request %s %s Success"),
*Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
});
FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
[this](const FDTFluxTrackedRequest& InReq, const FString& InError)
{
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("ContestRanking Request [%s] Error %s"),
*InReq.RequestId.ToString(), *InError);
});
// if Contest is not ended
for (auto ContestId : ForContests)
{
FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::ContestRanking,
ContestId, -1, -1, OnSuccess, OnError);
RequestIds.Add(ContestRequest);
}
return RequestIds;
}
return TArray<FGuid>();
}
TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestStageRankings(const TArray<FDTFluxStageKey> ForStages)
{
if (NetworkSubsystem)
{
TArray<FGuid> RequestIds;
FOnDTFluxRequestSuccess OnSuccess = FOnDTFluxRequestSuccess::CreateLambda(
[this](const FDTFluxTrackedRequest& Request)
{
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Stage Request %s %s Success"),
*Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
});
FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
[this](const FDTFluxTrackedRequest& InReq, const FString& InError)
{
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("StageRanking Request [%s] Error %s"),
*InReq.RequestId.ToString(), *InError);
});
// if Contest is not ended
for (auto StageKey : ForStages)
{
FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::StageRanking,
StageKey.ContestId, StageKey.StageId, -1, OnSuccess, OnError);
RequestIds.Add(ContestRequest);
}
return RequestIds;
}
return TArray<FGuid>();
}
TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestSplitRankings(const TArray<FDTFluxSplitKey> ForSplits)
{
if (NetworkSubsystem)
{
TArray<FGuid> RequestIds;
FOnDTFluxRequestSuccess OnSuccess = FOnDTFluxRequestSuccess::CreateLambda(
[this](const FDTFluxTrackedRequest& Request)
{
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Stage Request %s %s Success"),
*Request.RequestId.ToString(), *UEnum::GetValueAsString(Request.RequestType));
});
FOnDTFluxRequestError OnError = FOnDTFluxRequestError::CreateLambda(
[this](const FDTFluxTrackedRequest& InReq, const FString& InError)
{
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("StageRanking Request [%s] Error %s"),
*InReq.RequestId.ToString(), *InError);
});
// if Contest is not ended
for (auto SplitKey : ForSplits)
{
FGuid ContestRequest = NetworkSubsystem->SendTrackedRequestWithCallbacks(EDTFluxApiDataType::SplitRanking,
SplitKey.ContestId, SplitKey.StageId, SplitKey.SplitId, OnSuccess, OnError);
RequestIds.Add(ContestRequest);
}
return RequestIds;
}
return TArray<FGuid>();
}
void UDTFluxCoreSubsystem::SendTeamListRequest()
{
if (NetworkSubsystem)
@ -250,15 +414,16 @@ void UDTFluxCoreSubsystem::RequestAllSplitRankingOfContest(int InContestId, int
// TODO Implement this
}
FDTFluxStageRankings UDTFluxCoreSubsystem::GetStageRankings(FDTFluxStageKey StageKey)
{
if (DataStorage->StageRankings.Contains(StageKey))
{
return DataStorage->StageRankings[StageKey];
}
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Cannot find StageRankings for key [%s]"), *StageKey.GetDisplayName());
return FDTFluxStageRankings();
}
//
// FDTFluxStageRankings UDTFluxCoreSubsystem::GetStageRankings(FDTFluxStageKey StageKey)
// {
// if (DataStorage->StageRankings.Contains(StageKey))
// {
// return DataStorage->StageRankings[StageKey];
// }
// UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Cannot find StageRankings for key [%s]"), *StageKey.GetDisplayName());
// return FDTFluxStageRankings();
// }
void UDTFluxCoreSubsystem::RequestAllSplitRankingOfStage(int InContestId, int InStageId, int InSplitId)
{

161
Source/DTFluxCoreSubsystem/Private/DTFluxPursuitManager.cpp
View File

@ -13,35 +13,6 @@ UDTFluxPursuitManager::UDTFluxPursuitManager(const FObjectInitializer& ObjectIni
{
}
// TODO : Add way to pass MaxSimultaneousPursuit and MassStartDelay
// For now it's done in UPROPERTIES
void UDTFluxPursuitManager::InitPursuitForContests(const TArray<FDTFluxContest> InContests)
{
if (InitSubSystems())
{
for (const auto Contest : InContests)
{
FRequestData RequestData;
RequestData.ContestId = Contest.ContestId;
uint8 StageId = Contest.Stages.Last().StageId;
FGuid Guid = NetworkSubsystem->SendTrackedRequestWithCallback(EDTFluxApiDataType::StageRanking,
Contest.ContestId, StageId, -1,
FOnDTFluxTrackedRequestResponse::CreateUObject(
this,
&UDTFluxPursuitManager::OnRequestResponse),
FOnDTFluxTrackedRequestTimeout::CreateUObject(
this,
&UDTFluxPursuitManager::OnRequestTimeoutResponse),
FOnDTFluxRequestResponseError::CreateUObject(
this,
&UDTFluxPursuitManager::OnRequestError));
RequestData.RequestIds.Add(Guid);
PendingRequestData.Add(RequestData);
}
}
}
void UDTFluxPursuitManager::InitPursuit(const TArray<int> InContestIds, const int MaxSimultaneousPursuit)
{
CoreSubsystem = Cast<UDTFluxCoreSubsystem>(GetOuter());
@ -50,14 +21,19 @@ void UDTFluxPursuitManager::InitPursuit(const TArray<int> InContestIds, const in
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("CoreSubsystem is not Available !!!"));
return;
}
TArray<FDTFluxContest> Contests = TArray<FDTFluxContest>();
AllRankings.Reset();
for (const auto& ContestId : InContestIds)
{
FDTFluxContest Contest;
CoreSubsystem->GetContestForId(ContestId, Contest);
Contests.Add(Contest);
InitPursuitForContests(Contests);
if (CoreSubsystem->GetContestForId(ContestId, Contest))
{
BindRankings();
FDTFluxStageKey StageKey = FDTFluxStageKey(ContestId, Contest.GetLastStageId());
FDTFluxStageRankings TempStageRankings;
//Obtenir les ranking Frais.
CoreSubsystem->GetStageRankingsWithKey(StageKey, TempStageRankings, false);
PendingStageRanking.Add(StageKey, false);
}
}
}
@ -127,49 +103,6 @@ void UDTFluxPursuitManager::GetPursuit(TArray<FDTFluxPursuitInfo>& OutPursuitFoc
}
}
void UDTFluxPursuitManager::OnRequestResponse(const FGuid& RequestId, FDTFluxServerResponse& Response)
{
UE_LOG(logDTFluxCoreSubsystem, Log,
TEXT("UDTFluxPursuitManager::OnRequestResponse() Received Ranking For Stage %i"), Response.StageID)
UE_LOG(logDTFluxCoreSubsystem, Log, TEXT("Response is %s"), *UEnum::GetValueAsString(Response.GetResponseType()))
//check if request
if (Response.GetResponseType() == EDTFluxApiDataType::StageRanking)
{
FDTFluxStageRankings Rankings;
if (Response.ParseStageRankingResponse(Rankings))
{
FRequestData FoundData = FRequestData();
for (auto& PendingReq : PendingRequestData)
{
// Check for a matching PendingReq
if (PendingReq.IsWaitingFor(RequestId, Rankings))
{
FoundData = PendingReq;
// A request Is Terminated
UE_LOG(logDTFluxCoreSubsystem, Log,
TEXT("UDTFluxPursuitManager::OnRequestResponse() Ranking for Stage %i is complete"),
Response.StageID)
break;
}
}
if (InitPursuitForRequest(FoundData))
{
OnPursuitSequenceReady.Broadcast(MassStartTime, NextFocusPursuits, NextFocusPursuits, bFocusIsTruncate);
}
}
}
}
void UDTFluxPursuitManager::OnRequestTimeoutResponse(const FGuid& RequestId, const FString& TimeoutMessage)
{
UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Request Timeout [%s]"), *TimeoutMessage);
}
void UDTFluxPursuitManager::OnRequestError(const FGuid& RequestId, const FString& ErrorMessage)
{
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("Request Error [%s]"), *ErrorMessage);
}
bool UDTFluxPursuitManager::InitSubSystems()
{
if (NetworkSubsystem)
@ -180,23 +113,64 @@ bool UDTFluxPursuitManager::InitSubSystems()
return NetworkSubsystem != nullptr;
}
bool UDTFluxPursuitManager::InitPursuitForRequest(FRequestData Data)
bool UDTFluxPursuitManager::BindRankings()
{
if (CoreSubsystem)
{
if (!bIsRankingBounded)
{
CoreSubsystem->OnRequestedStageRankings.AddDynamic(this, &UDTFluxPursuitManager::OnRankingsReceived);
bIsRankingBounded = true;
}
return bIsRankingBounded;
}
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("CoreSubsystem is not Available !!!"));
return bIsRankingBounded = false;
}
void UDTFluxPursuitManager::UnbindRankings()
{
if (CoreSubsystem)
{
if (bIsRankingBounded)
{
CoreSubsystem->OnRequestedStageRankings.RemoveDynamic(this, &UDTFluxPursuitManager::OnRankingsReceived);
bIsRankingBounded = false;
return;
}
}
bIsRankingBounded = false;
UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("CoreSubsystem is not Available !!!"));
}
void UDTFluxPursuitManager::OnRankingsReceived(const FDTFluxStageKey NewStageKey,
const FDTFluxStageRankings NewStageRankings)
{
if (PendingStageRanking.Contains(NewStageKey))
{
PendingStageRanking.Remove(NewStageKey);
AllRankings.Add(NewStageRankings);
if (PendingStageRanking.IsEmpty())
{
//everything is ready to go compute and start
UnbindRankings();
LaunchPursuitSequence();
}
}
}
bool UDTFluxPursuitManager::LaunchPursuitSequence()
{
//Clean Data
NextFocusPursuits.Empty();
NextPursuits.Empty();
GroupedPursuit.Empty();
TArray<FDTFluxDetailedRankingItem> AllRankings;
TArray<FDTFluxPursuitInfo> AllPursuits;
TMap<FDateTime, FDTFluxPursuitGroup> TempGroups;
bIsSequenceDone = false;
// Full the Array Of Rankings
for (auto& KeyPair : Data.StageRankings)
for (auto& Ranking : AllRankings)
{
for (auto StageRanking : KeyPair.Value.Rankings)
for (auto StageRanking : Ranking.Rankings)
{
int ContestId = KeyPair.Value.ContestId;
int ContestId = Ranking.ContestId;
FDTFluxPursuitInfo PursuitInfo;
PursuitInfo.StartTime = StageRanking.StartTime;
PursuitInfo.Bib = StageRanking.Bib;
@ -204,11 +178,6 @@ bool UDTFluxPursuitManager::InitPursuitForRequest(FRequestData Data)
AllPursuits.Add(PursuitInfo);
}
}
// Sort Rankings
// AllPursuits.Sort([](const FDTFluxPursuitInfo& A, const FDTFluxPursuitInfo& B) {
// return A.StartTime < B.StartTime;
// });
for (auto& Pursuit : AllPursuits)
{
if (TempGroups.Contains(Pursuit.StartTime))
@ -251,5 +220,13 @@ bool UDTFluxPursuitManager::InitPursuitForRequest(FRequestData Data)
{
return A.StartTimeGlobal < B.StartTimeGlobal;
});
TArray<FDTFluxPursuitInfo> FocusPursuits;
TArray<FDTFluxPursuitInfo> NextPursuits;
bool bIsFocusTruncate = false;
GetPursuit(FocusPursuits, NextPursuits, bIsFocusTruncate);
FPursuitStaterData PursuitData = FPursuitStaterData(FocusPursuits, NextPursuits, MassStartTime, bIsFocusTruncate);
CoreSubsystem->OnPursuitSequenceReady.Broadcast(PursuitData);
return true;
}

81
Source/DTFluxCoreSubsystem/Public/DTFluxCoreSubsystem.h
View File

@ -2,6 +2,7 @@
#include "CoreMinimal.h"
#include "Containers/Deque.h"
#include "Types/Struct/FDTFluxPursuitInfo.h"
#include "Subsystems/EngineSubsystem.h"
#include "Types/Struct/DTFluxRaceDataStructs.h"
#include "Types/Struct/DTFluxTeamListStruct.h"
@ -15,6 +16,35 @@ class UDTFluxNetworkSubsystem;
class UDTFluxModelAsset;
class UDTFluxPursuitManager;
USTRUCT(BlueprintType)
struct FPursuitStaterData
{
GENERATED_BODY()
public:
FPursuitStaterData() = default;
FPursuitStaterData(const TArray<FDTFluxPursuitInfo>& InPursuitFocusNext,
const TArray<FDTFluxPursuitInfo>& InPursuitNext, const FDateTime& InMassStartTime,
const bool InIsFocusTruncate)
: PursuitFocusNext(InPursuitFocusNext), PursuitNext(InPursuitNext), MassStartTime(InMassStartTime),
bIsFocusTruncate(InIsFocusTruncate)
{
};
UPROPERTY(BlueprintReadOnly, Category="DTFlux|Pursuit")
TArray<FDTFluxPursuitInfo> PursuitFocusNext = TArray<FDTFluxPursuitInfo>();
UPROPERTY(BlueprintReadOnly, Category="DTFlux|Pursuit")
TArray<FDTFluxPursuitInfo> PursuitNext = TArray<FDTFluxPursuitInfo>();
UPROPERTY(BlueprintReadOnly, Category="DTFlux|Pursuit")
FDateTime MassStartTime = FDateTime::MinValue();
UPROPERTY(BlueprintReadOnly, Category="DTFlux|Pursuit")
bool bIsFocusTruncate = false;
};
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnPursuitSequenceReady, const FPursuitStaterData, PursuitInfoSequenceItem);
/**
*
*/
@ -24,15 +54,15 @@ class DTFLUXCORESUBSYSTEM_API UDTFluxCoreSubsystem : public UEngineSubsystem
GENERATED_BODY()
public:
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSplitRankings, FDTFluxSplitRankings&, SplitRankings);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSplitRankings, FDTFluxSplitRankings, SplitRankings);
UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
FOnSplitRankings OnSplitRankings;
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnStageRankings, FDTFluxStageRankings&, StageRankings);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnStageRankings, FDTFluxStageRankings, StageRankings);
UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
FOnStageRankings OnStageRankings;
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnContestRankings, FDTFluxContestRankings&, ContestRankings);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnContestRankings, FDTFluxContestRankings, ContestRankings);
UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
FOnContestRankings OnContestRankings;
@ -44,9 +74,46 @@ public:
UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
FOnTeamStatusUpdate OnTeamStatusUpdate;
DECLARE_DELEGATE_TwoParams(FOnRequestedStageRankings, const FDTFluxStageKey&, const FDTFluxContestRankings&);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnRequestedStageRankings, const FDTFluxStageKey, StageKey,
const FDTFluxStageRankings, StageRankings);
UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
FOnRequestedStageRankings OnRequestedStageRankings;
UPROPERTY(BlueprintAssignable, Category="DTFlux|Core Subsystem")
FOnPursuitSequenceReady OnPursuitSequenceReady;
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
bool GetContestRankings(const int ContestId, FDTFluxContestRankings& OutContestRankings);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
bool GetStageRankings(const int ContestId, const int StageId, FDTFluxStageRankings& OutStageRankings);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
bool GetSplitRankings(const int ContestId, const int StageId, const int SplitId,
FDTFluxSplitRankings& OutSplitRankings);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
bool GetStageRankingsWithKey(const FDTFluxStageKey StageKey, FDTFluxStageRankings& OutStageRankings,
const bool bShouldUseCached = true);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
bool GetSplitRankingsWithKey(const FDTFluxSplitKey SplitKey, FDTFluxSplitRankings& OutSplitRankings,
const bool bShouldUseCached = true);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
TArray<FGuid> TrackedRequestContestRankings(const TArray<int> ForContests);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
TArray<FGuid> TrackedRequestStageRankings(const TArray<FDTFluxStageKey> ForStages);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
TArray<FGuid> TrackedRequestSplitRankings(const TArray<FDTFluxSplitKey> ForSplits);
UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
UDTFluxPursuitManager* PursuitManager = nullptr;
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void SendTeamListRequest();
@ -68,9 +135,6 @@ public:
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void RequestAllSplitRankingOfContest(int InContestId, int InStageId);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
FDTFluxStageRankings GetStageRankings(FDTFluxStageKey StageKey);
UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
void RequestAllSplitRankingOfStage(int InContestId, int InStageId, int InSplitId);
@ -96,9 +160,6 @@ public:
UFUNCTION()
TArray<FDTFluxContest> GetContests();
UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
UDTFluxPursuitManager* PursuitManager = nullptr;
protected:
// ~Subsystem Interface
virtual void Initialize(FSubsystemCollectionBase& Collection) override;

38
Source/DTFluxCoreSubsystem/Public/DTFluxPursuitManager.h
View File

@ -65,10 +65,6 @@ struct FDTFluxPursuitGroup
bool bIsFocus = false;
};
DECLARE_DYNAMIC_MULTICAST_DELEGATE_FourParams(FOnPursuitSequenceReady, const FDateTime, MassStartTime,
const TArray<FDTFluxPursuitInfo>,
NextFocusPursuits,
const TArray<FDTFluxPursuitInfo>, NextPursuit, bool, bIsTrtuncate);
/**
*
@ -81,11 +77,6 @@ class DTFLUXCORESUBSYSTEM_API UDTFluxPursuitManager : public UObject
public:
UDTFluxPursuitManager(const FObjectInitializer& ObjectInitializer);
UPROPERTY(BlueprintReadOnly, VisibleAnywhere)
TArray<FDTFluxPursuitInfo> NextFocusPursuits;
UPROPERTY(BlueprintReadOnly, VisibleAnywhere)
TArray<FDTFluxPursuitInfo> NextPursuits;
UPROPERTY(BlueprintReadOnly, VisibleAnywhere)
bool bFocusIsTruncate = false;
@ -106,8 +97,6 @@ public:
UPROPERTY()
int CurrentIndex = -1;
UPROPERTY(BlueprintAssignable, Category="DTFlux|Pursuit")
FOnPursuitSequenceReady OnPursuitSequenceReady;
UFUNCTION(BlueprintCallable, Category="DTFlux|Pursuit", meta=(Keywords="pursuit, launch, poursuite"))
void InitPursuit(const TArray<int> InContestIds, const int MaxSimultaneousPursuit = 7);
@ -116,29 +105,30 @@ public:
void GetPursuit(TArray<FDTFluxPursuitInfo>& OutPursuitFocusNext, TArray<FDTFluxPursuitInfo>& OutPursuitNext,
bool& BIsFocusTruncate, const int MaxSimultaneousPursuit = 7);
UFUNCTION()
void OnRequestResponse(const FGuid& RequestId, FDTFluxServerResponse& Response);
UFUNCTION()
void OnRequestTimeoutResponse(const FGuid& RequestId, const FString& TimeoutMessage);
UFUNCTION()
void OnRequestError(const FGuid& RequestId, const FString& ErrorMessage);
UFUNCTION()
bool InitSubSystems();
UFUNCTION()
bool BindRankings();
UFUNCTION()
void UnbindRankings();
UFUNCTION()
void OnRankingsReceived(const FDTFluxStageKey NewStageKey, const FDTFluxStageRankings NewStageRankings);
private:
TArray<FRequestData> PendingRequestData;
TMap<FDTFluxStageKey, bool> PendingStageRanking;
TArray<FDTFluxStageRankings> AllRankings;
UDTFluxCoreSubsystem* CoreSubsystem = nullptr;
UDTFluxNetworkSubsystem* NetworkSubsystem = nullptr;
UPROPERTY()
bool bIsSequenceDone = true;
UPROPERTY()
bool bIsRankingBounded = false;
UFUNCTION()
void SetPursuitInfoIsMassStart(FDTFluxPursuitGroup NextFocusGroup);
UFUNCTION()
void InitPursuitForContests(const TArray<FDTFluxContest> InContests);
UFUNCTION()
bool InitPursuitForRequest(FRequestData Data);
bool LaunchPursuitSequence();
};