Added Blank Delegate for split Sensors + Added Getters for Contest/Stage/Split rankings for 1 participant + Global Cleaning

Source/DTFluxAssetsEditor/Private/Widget/DTFluxAssetModelDetailsWidget.cpp

@@ -1,6 +1,7 @@
 // Fill out your copyright notice in the Description page of Project Settings.
 #include "Widget/DTFluxAssetModelDetailsWidget.h"
 
+#include "DTFluxAssetsEditorModule.h"
 #include "Widgets/Layout/SBorder.h"
 #include "Widgets/Layout/SBox.h"
 #include "Widgets/Text/STextBlock.h"
@@ -23,19 +24,19 @@ TSharedRef<SWidget> SHierarchicalTreeItemRow::GenerateWidgetForColumn(const FNam
 {
 	if (!Item.IsValid())
 	{
-		UE_LOG(LogTemp, Warning, TEXT("GenerateWidgetForColumn: Invalid item for column %s"), *ColumnName.ToString());
+		// UE_LOG(logDTFluxAssetEditor, Warning, TEXT("GenerateWidgetForColumn: Invalid item for column %s"), *ColumnName.ToString());
 		return SNew(STextBlock).Text(FText::FromString("Invalid Item"));
 	}
 
 	if (!ParentWidget)
 	{
-		UE_LOG(LogTemp, Warning, TEXT("GenerateWidgetForColumn: Invalid ParentWidget for column %s"),
+		// UE_LOG(logDTFluxAssetEditor, Warning, TEXT("GenerateWidgetForColumn: Invalid ParentWidget for column %s"),
-		       *ColumnName.ToString());
+		//        *ColumnName.ToString());
 		return SNew(STextBlock).Text(FText::FromString("Invalid Parent"));
 	}
 
-	UE_LOG(LogTemp, VeryVerbose, TEXT("GenerateWidgetForColumn: %s for item %s"),
+	// UE_LOG(logDTFluxAssetEditor, VeryVerbose, TEXT("GenerateWidgetForColumn: %s for item %s"),
-	       *ColumnName.ToString(), *Item->Name);
+	//        *ColumnName.ToString(), *Item->Name);
 
 	if (ColumnName == "Name")
 	{
@@ -93,7 +94,7 @@ TSharedRef<SWidget> SHierarchicalTreeItemRow::GenerateWidgetForColumn(const FNam
 			.OverflowPolicy(ETextOverflowPolicy::Ellipsis);
 	}
 
-	UE_LOG(LogTemp, Warning, TEXT("GenerateWidgetForColumn: Unknown column %s"), *ColumnName.ToString());
+	UE_LOG(logDTFluxAssetEditor, Warning, TEXT("GenerateWidgetForColumn: Unknown column %s"), *ColumnName.ToString());
 	return SNew(STextBlock).Text(FText::FromString(FString::Printf(TEXT("Unknown: %s"), *ColumnName.ToString())));
 }
 
@@ -411,7 +412,7 @@ void SDTFluxAssetModelDetailsWidget::BuildContestHierarchy()
 		RootItems.Add(ContestItem);
 	}
 
-	UE_LOG(LogTemp, Log, TEXT("Built contest hierarchy with %d root contests"), RootItems.Num());
+	// UE_LOG(logDTFluxAssetEditor, Log, TEXT("Built contest hierarchy with %d root contests"), RootItems.Num());
 }
 
 void SDTFluxAssetModelDetailsWidget::BuildParticipantList()
@@ -420,11 +421,11 @@ void SDTFluxAssetModelDetailsWidget::BuildParticipantList()
 
 	if (!ModelAsset)
 	{
-		UE_LOG(LogTemp, Warning, TEXT("BuildParticipantList: ModelAsset is null!"));
+		UE_LOG(logDTFluxAssetEditor, Warning, TEXT("BuildParticipantList: ModelAsset is null!"));
-		return;
+		// return;
 	}
 
-	UE_LOG(LogTemp, Log, TEXT("BuildParticipantList: ModelAsset has %d participants"), ModelAsset->Participants.Num());
+	// UE_LOG(logDTFluxAssetEditor, Log, TEXT("BuildParticipantList: ModelAsset has %d participants"), ModelAsset->Participants.Num());
 
 	// Créer la liste des participants (pas de hiérarchie pour les participants)
 	for (const auto& ParticipantPair : ModelAsset->Participants)
@@ -433,12 +434,12 @@ void SDTFluxAssetModelDetailsWidget::BuildParticipantList()
 		auto ParticipantItem = FHierarchicalTreeItem::CreateParticipant(Participant);
 		ParticipantItems.Add(ParticipantItem);
 
-		UE_LOG(LogTemp, Log, TEXT("BuildParticipantList: Added participant %s (Bib: %d)"),
+		// UE_LOG(logDTFluxAssetEditor, Log, TEXT("BuildParticipantList: Added participant %s (Bib: %d)"),
-		       *ParticipantItem->Name, ParticipantItem->Bib);
+		//        *ParticipantItem->Name, ParticipantItem->Bib);
 	}
 
-	UE_LOG(LogTemp, Log, TEXT("BuildParticipantList: Built participant list with %d participants"),
+	// UE_LOG(logDTFluxAssetEditor, Log, TEXT("BuildParticipantList: Built participant list with %d participants"),
-	       ParticipantItems.Num());
+	//        ParticipantItems.Num());
 }
 
 // ===== CALLBACKS TREEVIEW =====
@@ -448,12 +449,12 @@ TSharedRef<ITableRow> SDTFluxAssetModelDetailsWidget::OnGenerateRowForTree(
 {
 	if (!Item.IsValid())
 	{
-		UE_LOG(LogTemp, Warning, TEXT("OnGenerateRowForTree: Invalid item!"));
+		UE_LOG(logDTFluxAssetEditor, Warning, TEXT("OnGenerateRowForTree: Invalid item!"));
 		return SNew(STableRow<FHierarchicalTreeItemPtr>, OwnerTable);
 	}
 
-	UE_LOG(LogTemp, Log, TEXT("OnGenerateRowForTree: Generating row for %s (Type: %d)"),
+	// UE_LOG(logDTFluxAssetEditor, Log, TEXT("OnGenerateRowForTree: Generating row for %s (Type: %d)"),
-	       *Item->Name, (int32)Item->Type);
+	//        *Item->Name, (int32)Item->Type);
 
 	return SNew(SHierarchicalTreeItemRow, OwnerTable)
 		.Item(Item)
@@ -536,7 +537,7 @@ FReply SDTFluxAssetModelDetailsWidget::OnExpandAllClicked()
 		}
 	}
 
-	UE_LOG(LogTemp, Log, TEXT("Expanded all contests"));
+	// UE_LOG(logDTFluxAssetEditor, Log, TEXT("Expanded all contests"));
 	return FReply::Handled();
 }
 
@@ -550,14 +551,14 @@ FReply SDTFluxAssetModelDetailsWidget::OnCollapseAllClicked()
 		}
 	}
 
-	UE_LOG(LogTemp, Log, TEXT("Collapsed all contests"));
+	// UE_LOG(logDTFluxAssetEditor, Log, TEXT("Collapsed all contests"));
 	return FReply::Handled();
 }
 
 FReply SDTFluxAssetModelDetailsWidget::OnRefreshClicked()
 {
 	RefreshData();
-	UE_LOG(LogTemp, Log, TEXT("Data refreshed"));
+	// UE_LOG(logDTFluxAssetEditor, Log, TEXT("Data refreshed"));
 	return FReply::Handled();
 }
 
@@ -567,21 +568,17 @@ void SDTFluxAssetModelDetailsWidget::RefreshData()
 {
 	if (!ModelAsset)
 	{
-		UE_LOG(LogTemp, Warning, TEXT("ModelAsset is null!"));
+		UE_LOG(logDTFluxAssetEditor, Warning, TEXT("ModelAsset is null!"));
 		return;
 	}
 
-	UE_LOG(LogTemp, Log, TEXT("RefreshData: Starting refresh for ModelAsset %s"), *ModelAsset->GetName());
+	// UE_LOG(logDTFluxAssetEditor, Log, TEXT("RefreshData: Starting refresh for ModelAsset %s"), *ModelAsset->GetName());
-
-	// Nettoyer les données existantes
 	RootItems.Empty();
 	ParticipantItems.Empty();
 
-	// Construire la hiérarchie
 	BuildContestHierarchy();
 	BuildParticipantList();
 
-	// Refresh les vues
 	if (ContestTreeView.IsValid())
 	{
 		ContestTreeView->RequestTreeRefresh();
@@ -591,9 +588,8 @@ void SDTFluxAssetModelDetailsWidget::RefreshData()
 	{
 		ParticipantTreeView->RequestTreeRefresh();
 	}
-
+	// UE_LOG(logDTFluxAssetEditor, Log, TEXT("RefreshData: Completed successfully - %d contests, %d participants"), RootItems.Num(),
-	UE_LOG(LogTemp, Log, TEXT("RefreshData: Completed successfully - %d contests, %d participants"), RootItems.Num(),
+	//        ParticipantItems.Num());
-	       ParticipantItems.Num());
 }
 
 // ===== MÉTHODES UTILITAIRES =====
@@ -635,7 +631,6 @@ FText SDTFluxAssetModelDetailsWidget::GetStatsText() const
 {
 	if (!ModelAsset)
 		return FText::FromString("No data");
-
 	return FText::FromString(FString::Printf(
 		TEXT("Contests: [%d] Participants: [%d] Persons: [%d]"),
 		ModelAsset->Contests.Num(),

Source/DTFluxAssetsEditor/Public/Widget/DTFluxAssetModelDetailsWidget.h

@@ -137,7 +137,7 @@ struct FHierarchicalTreeItem
 typedef TSharedPtr<FHierarchicalTreeItem> FHierarchicalTreeItemPtr;
 
 /**
- * Widget avec STreeView simple et efficace
+ * ModelAsset TreeviewWidget
  */
 class DTFLUXASSETSEDITOR_API SDTFluxAssetModelDetailsWidget : public SCompoundWidget
 {
@@ -152,40 +152,33 @@ public:
 	void Construct(const FArguments& InArgs);
 	void RefreshData();
 
-	// Méthodes publiques pour la sous-classe Row
 	FSlateColor GetItemTypeColor(FHierarchicalTreeItem::EItemType Type) const;
 	const FSlateBrush* GetItemIcon(FHierarchicalTreeItem::EItemType Type) const;
 
 private:
-	// Données
 	UDTFluxModelAsset* ModelAsset = nullptr;
-	TArray<FHierarchicalTreeItemPtr> RootItems; // Contests racines avec hiérarchie
+	TArray<FHierarchicalTreeItemPtr> RootItems;
-	TArray<FHierarchicalTreeItemPtr> ParticipantItems; // Participants séparés
+	TArray<FHierarchicalTreeItemPtr> ParticipantItems;
 
-	// Widgets - TreeView simple
 	TSharedPtr<STreeView<FHierarchicalTreeItemPtr>> ContestTreeView;
 	TSharedPtr<STreeView<FHierarchicalTreeItemPtr>> ParticipantTreeView;
 	TSharedPtr<STextBlock> StatsText;
 	TSharedPtr<STextBlock> SelectionText;
 
-	// Méthodes de construction
 	void BuildContestHierarchy();
 	void BuildParticipantList();
 
-	// Callbacks TreeView
 	TSharedRef<ITableRow> OnGenerateRowForTree(FHierarchicalTreeItemPtr Item,
 	                                           const TSharedRef<STableViewBase>& OwnerTable);
 	void OnGetChildrenForTree(FHierarchicalTreeItemPtr Item, TArray<FHierarchicalTreeItemPtr>& OutChildren);
 	void OnTreeSelectionChanged(FHierarchicalTreeItemPtr SelectedItem, ESelectInfo::Type SelectInfo);
 	void OnSetExpansionRecursive(FHierarchicalTreeItemPtr Item, bool bIsExpanded);
 
-	// Callbacks des boutons
 	FReply OnRefreshClicked();
 	FReply OnExpandAllClicked();
 	FReply OnCollapseAllClicked();
 
 	EActiveTimerReturnType ForceInitialLayout(double InCurrentTime, float InDeltaTime);
 
-	// Utilitaires
 	FText GetStatsText() const;
 };

Source/DTFluxCore/Public/Types/Enum/DTFluxModelEnums.h

@@ -11,79 +11,80 @@
 UENUM(BlueprintType, Category="DTFlux|Model")
 enum class EDTFluxParticipantStatusType : uint8
 {
-	Normal 		= 0 		UMETA(DisplayName="Normal"),
+	Normal = 0 UMETA(DisplayName="Normal"),
-	OutOfRace 	= 1 		UMETA(DisplayName="HorsCourse"),
+	OutOfRace = 1 UMETA(DisplayName="HorsCourse"),
-	DSQ 		= 2 		UMETA(DisplayName="Disqualifié"),
+	DSQ = 2 UMETA(DisplayName="Disqualifié"),
-	DNF 		= 3 		UMETA(DisplayName="Abandon"),
+	DNF = 3 UMETA(DisplayName="Abandon"),
-	DNS 		= 4 		UMETA(DisplayName="NonPartant"),
+	DNS = 4 UMETA(DisplayName="NonPartant"),
-	NotLinedUp 	= 5 		UMETA(DisplayName="NonPresentAuDépart"),
+	NotLinedUp = 5 UMETA(DisplayName="NonPresentAuDépart"),
-	Unknown 	= 1 << 4	UMETA(DisplayName="Unknown")
+	Unknown = 1 << 4 UMETA(DisplayName="Unknown")
 };
 
 
 UENUM(BlueprintType, meta=(Bitflags, UseEnumValuesAsMaskValuesInEditor=true))
 enum class EParticipantSortingType : uint8
 {
-
+	None = 0 << 1 UMETA(DisplayName="Normal"),
-	None				= 0 << 1	UMETA(DisplayName="Normal"),
+	Alpha = 1 << 1 UMETA(DisplayName="Aplha"),
-	Alpha				= 1	<< 1	UMETA(DisplayName="Aplha"),
+	PoursuiteStartTime = 1 << 2 UMETA(DisplayName="Poursuite StartTime"),
-	PoursuiteStartTime  = 1	<< 2	UMETA(DisplayName="Poursuite StartTime"),
+	Rank = 1 << 3 UMETA(DisplayName="Rank"),
-	Rank				= 1	<< 3	UMETA(DisplayName="Rank"),
+	IgnoreEmpty = 1 << 4 UMETA(DisplayName="IgnoreEmpty"),
-	IgnoreEmpty			= 1 << 4	UMETA(DisplayName="IgnoreEmpty"),
 };
+
 ENUM_CLASS_FLAGS(EParticipantSortingType);
 
 
-UENUM(BlueprintType, meta=(Bitflags, UseEnumValuesAsMaskValuesInEditor=true))
+UENUM(BlueprintType)
 enum class EDTFluxFinisherType : uint8
 {
-	None	= 0b0000000		UMETA(DisplayName="Unknown"),
+	None = 0b0000000 UMETA(DisplayName="Unknown"),
-	Finish	= 0b0000001		UMETA(DisplayName="Finish"),
+	Finish = 0b0000001 UMETA(DisplayName="Finish"),
-	Winner	= 0b0000010		UMETA(DisplayName="Winner"),
+	Winner = 0b0000010 UMETA(DisplayName="Winner"),
-	Spotter = 0b0000100		 UMETA(DisplayName="Spotter"),
+	Spotter = 0b0000100 UMETA(DisplayName="Spotter"),
 };
-ENUM_CLASS_FLAGS(EDTFluxFinisherType);
 
 UENUM(BlueprintType, meta=(Bitflags, UseEnumValuesAsMaskValuesInEditor=true))
 enum class EDTFluxSplitType : uint8
 {
-	None			= 0b00000000		UMETA(DisplayName="Undefined"),
+	None = 0b00000000 UMETA(DisplayName="Undefined"),
-	PreFinnish		= 0b00000001		UMETA(DisplayName="PreFinnishSplit"),
+	PreFinnish = 0b00000001 UMETA(DisplayName="PreFinnishSplit"),
-	Finish			= 0b00000010		UMETA(DisplayName="FinishSplit"),
+	Finish = 0b00000010 UMETA(DisplayName="FinishSplit"),
-	Regular			= 0b00000100		 UMETA(DisplayName="Regular"),
+	Regular = 0b00000100 UMETA(DisplayName="Regular"),
 };
+
 ENUM_CLASS_FLAGS(EDTFluxSplitType);
 
 
 UENUM(BlueprintType, meta=(Bitflags, UseEnumValuesAsMaskValuesInEditor=true))
-enum class EDTFluxSortingFilter  : uint8
+enum class EDTFluxSortingFilter : uint8
 {
-	None			= 0b00000000				UMETA(DisplayName="No Sorting"),
+	None = 0b00000000 UMETA(DisplayName="No Sorting"),
-	IgnoreStatusOut	= 0b00000001				UMETA(DisplayName="IgnoreStatusOut"),
+	IgnoreStatusOut = 0b00000001 UMETA(DisplayName="IgnoreStatusOut"),
-	Ascending		= 0b00000010				UMETA(DisplayName="Ascending"),
+	Ascending = 0b00000010 UMETA(DisplayName="Ascending"),
-	Descending		= 0b00000100				UMETA(DisplayName="Descending"),
+	Descending = 0b00000100 UMETA(DisplayName="Descending"),
-	IgnoreEmpty		= 0b00001000				UMETA(DisplayName="IgnoreEmpty"),
+	IgnoreEmpty = 0b00001000 UMETA(DisplayName="IgnoreEmpty"),
-	ByRank			= 0b00010000				UMETA(DisplayName="ByRank"),
+	ByRank = 0b00010000 UMETA(DisplayName="ByRank"),
-	ByAlpha			= 0b01000000				UMETA(DisplayName="ByAlpha"),
+	ByAlpha = 0b01000000 UMETA(DisplayName="ByAlpha"),
-	ByStartTime		= 0b00100000				UMETA(DisplayName="ByStartTime"),
+	ByStartTime = 0b00100000 UMETA(DisplayName="ByStartTime"),
-	AscendingByRank = Ascending | ByRank		UMETA(DisplayName="AscendingByRank"),	
+	AscendingByRank = Ascending | ByRank UMETA(DisplayName="AscendingByRank"),
-	DescendingByRank= Descending | ByRank		UMETA(DisplayName="DescendingByRank")	
+	DescendingByRank = Descending | ByRank UMETA(DisplayName="DescendingByRank")
 };
+
 ENUM_CLASS_FLAGS(EDTFluxSortingFilter);
 
 
 UENUM(BlueprintType)
 enum class EDTFluxSortingRankingType: uint8
 {
-	Rank			= 0b00000000 							UMETA(DisplayName="Rank (Default)"),
+	Rank = 0b00000000 UMETA(DisplayName="Rank (Default)"),
-	Name			= 0b00000001 							UMETA(DisplayName="Name"),
+	Name = 0b00000001 UMETA(DisplayName="Name"),
-	Bib				= 0b00000010 							UMETA(DisplayName="Bib"),
+	Bib = 0b00000010 UMETA(DisplayName="Bib"),
-	TimeSwim		= 0b00000100 							UMETA(DisplayName="Swimming Time"),
+	TimeSwim = 0b00000100 UMETA(DisplayName="Swimming Time"),
-	TimeTransition	= 0b00001000 							UMETA(DisplayName="Transition Time"),
+	TimeTransition = 0b00001000 UMETA(DisplayName="Transition Time"),
-	TimeRun			= TimeSwim|TimeTransition 				UMETA(DisplayName="Running Time"),
+	TimeRun = TimeSwim | TimeTransition UMETA(DisplayName="Running Time"),
-	StartTime		= 0b00001110							UMETA(DisplayName="StartTime"),
+	StartTime = 0b00001110 UMETA(DisplayName="StartTime"),
-	Gap				= 0b00010000 							UMETA(DisplayName="StartTime"),
+	Gap = 0b00010000 UMETA(DisplayName="StartTime"),
-	SwimSpeed		= 0b00100000 							UMETA(DisplayName="StartTime"),
+	SwimSpeed = 0b00100000 UMETA(DisplayName="StartTime"),
-	RunningSpeed	= 0b01000000 							UMETA(DisplayName="StartTime"),
+	RunningSpeed = 0b01000000 UMETA(DisplayName="StartTime"),
-	TotalSpeed		= 0b10000000 							UMETA(DisplayName="StartTime"),
+	TotalSpeed = 0b10000000 UMETA(DisplayName="StartTime"),
 };

Source/DTFluxCore/Public/Types/Struct/DTFluxFinishData.h

@@ -15,6 +15,7 @@ USTRUCT(BlueprintType, Category="DTFlux|Model")
 struct DTFLUXCORE_API FDTFluxFinisherData
 {
 	GENERATED_BODY()
+
 public:
 	UPROPERTY(BlueprintReadWrite, Category="DTFlux|Model")
 	int ContestId;
@@ -23,9 +24,7 @@ public:
 	UPROPERTY(BlueprintReadWrite, Category="DTFlux|Model")
 	int Bib = -1;
 	UPROPERTY(BlueprintReadWrite, Category="DTFlux|Model")
-	FDTFluxStageRanking SplitRanking;
+	FString Time;
-	UPROPERTY(BlueprintReadWrite, Category="DTFlux|Model")
-	FDTFluxStageRanking StageRanking;
 };
 
 USTRUCT(BlueprintType, Category="FDTFlux|Model")
@@ -64,4 +63,3 @@ struct DTFLUXCORE_API FDTFluxContestFinished
 	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Subsystem|Events")
 	TArray<FDTFluxStageRanking> Rankings;
 };
-

Source/DTFluxCore/Public/Types/Struct/DTFluxRankingStructs.h

@@ -57,7 +57,7 @@ public:
 };
 
 /**
- * @struct FDTFluxStageRanking
+ * @struct FDTFluxDetailedRankingItem
  * Representing a stage ranking for a participant
  */
 USTRUCT(BlueprintType, Category="DTFlux|Model")
@@ -125,7 +125,7 @@ struct FDTFluxStageRanking : public FDTFluxDetailedRankingItem
  * This struct is only a cosmetic Struct
  */
 USTRUCT(BlueprintType, Category="DTFlux|Model")
-struct DTFLUXCORE_API FDTFluxSplitRanking : public FDTFluxStageRanking
+struct DTFLUXCORE_API FDTFluxSplitRanking : public FDTFluxDetailedRankingItem
 {
 	GENERATED_BODY()
 };

Source/DTFluxCore/Public/Types/Struct/DTFluxSplitSensor.h

@@ -32,6 +32,4 @@ public:
 	FString Gap = "-";
 	UPROPERTY(BlueprintReadOnly, VisibleAnywhere)
 	int Rank;
-	
 };
-

Source/DTFluxCoreSubsystem/Private/DTFluxCoreSubsystem.cpp

@@ -288,6 +288,76 @@ void UDTFluxCoreSubsystem::SendRequest(const FString& Message)
 	}
 }
 
+bool UDTFluxCoreSubsystem::GetStageRankingForBib(const int ContestId, const int StageId, const int Bib,
+                                                 FDTFluxStageRanking& OutStageRanking)
+{
+	if (DataStorage)
+	{
+		FDTFluxStageKey StageKey(ContestId, StageId);
+		if (DataStorage->StageRankings.Contains(StageKey))
+		{
+			FDTFluxStageRankings StageRankings = DataStorage->StageRankings[StageKey];
+			for (auto& Ranking : StageRankings.Rankings)
+			{
+				if (Ranking.Bib == Bib)
+				{
+					OutStageRanking = static_cast<FDTFluxStageRanking>(Ranking);
+					return true;
+				}
+			}
+		}
+		UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Unable to find StageRanking for Bib %i"), Bib);
+		return false;
+	}
+	UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("DataStorage not available"));
+	return false;
+}
+
+bool UDTFluxCoreSubsystem::GetSplitRankingForBib(const int ContestId, const int StageId, const int SplitId,
+                                                 const int Bib, FDTFluxSplitRanking& OutSplitRankings)
+{
+	if (DataStorage)
+	{
+		FDTFluxSplitKey SplitKey(ContestId, StageId, SplitId);
+		if (DataStorage->SplitRankings.Contains(SplitKey))
+		{
+			FDTFluxSplitRankings SplitRankings = DataStorage->SplitRankings[SplitKey];
+			for (auto& Ranking : SplitRankings.Rankings)
+			{
+				if (Ranking.Bib == Bib)
+				{
+					OutSplitRankings = static_cast<FDTFluxSplitRanking>(Ranking);
+					return true;
+				}
+			}
+		}
+		UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Unable to find SplitRanking for Bib %i"), Bib);
+		return false;
+	}
+	UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("DataStorage not available"));
+	return false;
+}
+
+bool UDTFluxCoreSubsystem::GetContestRanking(const int ContestId, FDTFluxContestRanking& OutContestRanking)
+{
+	if (DataStorage)
+	{
+		FDTFluxContest Contest;
+		if (GetContestForId(ContestId, Contest))
+		{
+			for (auto& Ranking : DataStorage->ContestRankings[ContestId].Rankings)
+			{
+				OutContestRanking = Ranking;
+				return true;
+			}
+		}
+		UE_LOG(logDTFluxCoreSubsystem, Warning, TEXT("Unable to find ContestRanking for ContestId %i"), ContestId);
+		return false;
+	}
+	UE_LOG(logDTFluxCoreSubsystem, Error, TEXT("DataStorage not available"));
+	return false;
+}
+
 bool UDTFluxCoreSubsystem::GetContestRankings(const int ContestId,
                                               FDTFluxContestRankings& OutContestRankings)
 {
@@ -468,13 +538,15 @@ TArray<FGuid> UDTFluxCoreSubsystem::TrackedRequestSplitRankings(const TArray<FDT
 	return TArray<FGuid>();
 }
 
-const FDTFluxParticipant UDTFluxCoreSubsystem::GetParticipant(int InBib)
+bool UDTFluxCoreSubsystem::GetParticipant(int InBib, FDTFluxParticipant& OutParticipant)
 {
 	if (DataStorage->Participants.Contains(InBib))
 	{
-		return DataStorage->Participants[InBib];
+		OutParticipant = DataStorage->Participants[InBib];
+		return true;
 	}
-	return FDTFluxParticipant();
+
+	return false;
 }
 
 TArray<int> UDTFluxCoreSubsystem::GetCurrentContestsId()

Source/DTFluxCoreSubsystem/Public/DTFluxCoreSubsystem.h

@@ -59,6 +59,33 @@ public:
 	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
 	UDTFluxPursuitManager* PursuitManager = nullptr;
 
+	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnSplitSensor, FDTFluxSplitSensorInfo, SplitSensorInfo);
+
+	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
+	FOnSplitSensor OnSplitSensor;
+
+	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnFinisher, FDTFluxSplitSensorInfo, SplitSensorInfo);
+
+	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
+	FOnFinisher OnFinisher;
+
+	DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnWinner, FDTFluxSplitSensorInfo, SplitSensorInfo);
+
+	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")
+	FOnWinner OnWinner;
+
+
+	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
+	bool GetStageRankingForBib(const int ContestId, const int StageId, const int Bib,
+	                           FDTFluxStageRanking& OutStageRankings);
+
+	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
+	bool GetSplitRankingForBib(const int ContestId, const int StageId, const int SplitId, const int Bib,
+	                           FDTFluxSplitRanking& OutSplitRankings);
+
+	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
+	bool GetContestRanking(const int ContestId, FDTFluxContestRanking& OutContestRanking);
+
 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
 	bool GetContestRankings(const int ContestId, FDTFluxContestRankings& OutContestRankings);
 
@@ -88,7 +115,7 @@ public:
 
 
 	UFUNCTION(BlueprintCallable, Category="DTFlux|Core Subsystem")
-	const FDTFluxParticipant GetParticipant(int InBib);
+	bool GetParticipant(int InBib, FDTFluxParticipant& OutParticipant);
 
 	//TODO : this must be a ProjectSetting
 	UPROPERTY(BlueprintReadOnly, Category="DTFlux|Core Subsystem")

Source/DTFluxUtilities/Private/FTDFluxUtils.cpp

@@ -9,7 +9,8 @@ FText UFTDFluxUtils::GetFormatedName(const int& Bib, const int MaxChar, const FS
                                      const FString OverFlowChar)
 {
 	UDTFluxCoreSubsystem* CoreSubsystem = GEngine->GetEngineSubsystem<UDTFluxCoreSubsystem>();
-	const FDTFluxParticipant OutParticipant = CoreSubsystem->GetParticipant(Bib);
+	FDTFluxParticipant OutParticipant;
+	CoreSubsystem->GetParticipant(Bib, OutParticipant);
 	return OutParticipant.GetFormattedNameText(MaxChar, Separator, OverFlowChar);
 }