SCR_DebriefingScreenComponent.c

Go to the documentation of this file.

[ComponentEditorProps(category: "GameScripted/GameMode/Components", description: "Debriefing screen shown after game ends")]
class SCR_DebriefingScreenComponentClass : SCR_DeployMenuBaseScreenComponentClass
{
}

class SCR_DebriefingScreenComponent : SCR_DeployMenuBaseScreenComponent
{
}

[BaseContainerProps(), SCR_ContainerActionTitle()]
class SCR_DebriefingScreenUnevenFourTiles : SCR_DeployMenuBaseScreenLayout
{
    [Attribute(defvalue: "{F7138F20BD16D89A}UI/layouts/Menus/DeployMenu/DebriefingScreenFourUnevenTiles.layout")]
    protected ResourceName m_sFourUnevenTilesLayout;
 
    [Attribute()]
    protected ref SCR_WelcomeScreenBaseContent m_TopLeftTile;
 
    [Attribute()]
    protected ref SCR_WelcomeScreenBaseContent m_TopRightTile;
 
    [Attribute()]
    protected ref SCR_WelcomeScreenBaseContent m_BottomLeftTile;
    
    [Attribute()]
    protected ref SCR_WelcomeScreenBaseContent m_BottomRightTile;
    
    protected const string WELCOME_CONTENT = "WelcomeContent";
    
    protected const string TOP_LEFT_TILE = "TopLeftTile";
    protected const string TOP_RIGHT_TILE = "TopRightTile";
    protected const string BOTTOM_LEFT_TILE = "BottomLeftTile";
    protected const string BOTTOM_RIGHT_TILE = "BottomRightTile";
    
    protected const string TOP_LEFT_TILE_BUTTON = "TopLeftTileButton";
    protected const string TOP_RIGHT_TILE_BUTTON = "TopRightTileButton";
    protected const string BOTTOM_LEFT_TILE_BUTTON = "BottomLeftTileButton";
    protected const string BOTTOM_RIGHT_TILE_BUTTON = "BottomRightTileButton";
 
    //------------------------------------------------------------------------------------------------
    override void InitContent(SCR_WelcomeScreenMenu menu)
    {
        Widget targetColumn = menu.GetRootWidget().FindAnyWidget(WELCOME_CONTENT);
        if (!targetColumn)
            return;
 
        GetGame().GetWorkspace().CreateWidgets(m_sFourUnevenTilesLayout, targetColumn);
 
        if (m_TopLeftTile)
        {
            m_aScreenBaseContents.Insert(m_TopLeftTile);
            m_TopLeftTile.InitContent(menu, TOP_LEFT_TILE, TOP_LEFT_TILE_BUTTON);
        }
 
        if (m_TopRightTile)
        {
            m_aScreenBaseContents.Insert(m_TopRightTile);
            m_TopRightTile.InitContent(menu, TOP_RIGHT_TILE, TOP_RIGHT_TILE_BUTTON);
        }
 
        if (m_BottomLeftTile)
        {
            m_aScreenBaseContents.Insert(m_BottomLeftTile);
            m_BottomLeftTile.InitContent(menu, BOTTOM_LEFT_TILE, BOTTOM_LEFT_TILE_BUTTON);
        }
        
        if (m_BottomRightTile)
        {
            m_aScreenBaseContents.Insert(m_BottomRightTile);
            m_BottomRightTile.InitContent(menu, BOTTOM_RIGHT_TILE, BOTTOM_RIGHT_TILE_BUTTON);
        }
    }
}

[BaseContainerProps(), SCR_ContainerActionTitle()]
class SCR_DebriefingScreenBigImageContent : SCR_WelcomeScreenBaseContent
{
    [Attribute("", UIWidgets.ResourcePickerThumbnail, "Big image to be shown", params: "edds")]
    protected ResourceName m_sContentImage;
 
    [Attribute(defvalue: "{6CD5DC3DE2C54BBE}UI/layouts/Menus/DeployMenu/DebriefingScreenBigImageTile.layout")]
    protected ResourceName m_sBigImageLayout;
 
    //------------------------------------------------------------------------------------------------
    override void InitContent(SCR_WelcomeScreenMenu menu, string column, string columnButton)
    {
        Widget targetTile = menu.GetRootWidget().FindAnyWidget(column);
        if (!targetTile)
            return;
        
        Widget bigImageWidget = GetGame().GetWorkspace().CreateWidgets(m_sBigImageLayout, targetTile);
        if (!bigImageWidget)
            return;
 
        ImageWidget imageWidget = ImageWidget.Cast(bigImageWidget.FindAnyWidget("ImageWidget"));
        if (imageWidget && m_sContentImage)
            imageWidget.LoadImageTexture(0, m_sContentImage, false, false);
    }
 
    //------------------------------------------------------------------------------------------------
    ResourceName GetImage()
    {
        return m_sContentImage;
    }
}

[BaseContainerProps(), SCR_ContainerActionTitle()]
class SCR_DebriefingScreenSummaryContent : SCR_WelcomeScreenBaseContent
{
    [Attribute()]
    protected string m_sTitleText;
    
    [Attribute()]
    protected string m_sSubtitleText;
    
    [Attribute()]
    protected string m_sSubtitleLostText;
    
    [Attribute()]
    protected string m_sDescriptionText;
 
    [Attribute(defvalue: "{10A7983E48474CB2}UI/layouts/Menus/DeployMenu/DebriefingScreenSummaryTile.layout")]
    protected ResourceName m_sSummaryLayout;
    
    protected Widget m_wSummaryWidget;
 
    //------------------------------------------------------------------------------------------------
    override void InitContent(SCR_WelcomeScreenMenu menu, string column, string columnButton)
    {
        m_sContentName = column;
        
        Widget targetTile = menu.GetRootWidget().FindAnyWidget(column);
        if (!targetTile)
            return;
        
        m_wSummaryWidget = GetGame().GetWorkspace().CreateWidgets(m_sSummaryLayout, targetTile);
        if (!m_wSummaryWidget)
            return;
 
        FillSummaryWidget();
        
        //Invokers for in-game possibility to update these strings
        //SOMETHING.SOMEINVOKER().Insert(UpdateSummarySubtitle);
        //SOMETHING.SOMEINVOKER().Insert(UpdateSummaryDescription);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void FillSummaryWidget()
    {
        string characterRank = "";
        string subtitle = GetSubtitleLostText();
        IEntity player = GetGame().GetPlayerController().GetControlledEntity();
        if (player)
        {
            SCR_CharacterRankComponent rankComponent = SCR_CharacterRankComponent.Cast(player.FindComponent(SCR_CharacterRankComponent));
            if (rankComponent)
                characterRank = rankComponent.GetCharacterRankName(player);
        }
        
        SCR_BaseGameMode gamemode = SCR_BaseGameMode.Cast(GetGame().GetGameMode());
        if (!gamemode)
            return;
        
        SCR_FactionManager factionManager = SCR_FactionManager.Cast(GetGame().GetFactionManager());
        if (!factionManager)
            return;
            
        Faction faction = factionManager.GetLocalPlayerFaction();
        if (!faction)
            return;
        
        SCR_GameModeEndData endData = gamemode.GetEndGameData();
        if (endData)
        {
            array<int> winnerIds = {};
            array<int> winnerFactionIds = {};
            endData.GetWinnerIds(winnerIds);
            endData.GetFactionWinnerIds(winnerFactionIds);
            if (!winnerFactionIds.IsEmpty())
            {
                if (winnerFactionIds.Contains(factionManager.GetFactionIndex(faction)))
                    subtitle = GetSubtitleText();
            }
            else if (!winnerIds.IsEmpty())
            {
                int playerID = GetGame().GetPlayerController().GetPlayerId();
                if (winnerIds.Contains(playerID))
                    subtitle = GetSubtitleText();
            }
        }
        
        RichTextWidget subtitleText = RichTextWidget.Cast(m_wSummaryWidget.FindAnyWidget("SubtitleText"));
        if (subtitleText)
            subtitleText.SetTextFormat(subtitle, characterRank, string.Format("<color rgba=%1>%2</color>", UIColors.FormatColor(UIColors.CONTRAST_COLOR), SCR_PlayerNamesFilterCache.GetInstance().GetPlayerDisplayName(GetGame().GetPlayerController().GetPlayerId())));
 
        RichTextWidget descriptionText = RichTextWidget.Cast(m_wSummaryWidget.FindAnyWidget("DescriptionText"));
        if (!descriptionText)
            return;
        
        descriptionText.SetText(GetDescriptionText());
        
        if (SCR_StringHelper.IsEmptyOrWhiteSpace(GetDescriptionText())) 
        {
            SCR_GameOverScreenManagerComponent gameOverScreenMgr = SCR_GameOverScreenManagerComponent.Cast(gamemode.FindComponent(SCR_GameOverScreenManagerComponent));
            if (!gameOverScreenMgr)
                return;
            
            SCR_GameOverScreenConfig gameOverConfig = gameOverScreenMgr.GetGameOverConfig();
            if (!gameOverConfig)
                return;
            
            SCR_BaseGameOverScreenInfo gameOverScreenInfo;
            gameOverConfig.GetGameOverScreenInfo(gameOverScreenMgr.GetCurrentGameOverType(), gameOverScreenInfo);
            if (!gameOverScreenInfo)
                return;
            
            if (!SCR_StringHelper.IsEmptyOrWhiteSpace(gameOverScreenInfo.GetDebriefing(faction, null))) 
                descriptionText.SetText(gameOverScreenInfo.GetDebriefing(faction, null));
            else
                descriptionText.SetText(gameOverScreenInfo.GetSubtitle(faction, null));
        }
    }
    
    //------------------------------------------------------------------------------------------------
    void UpdateSummarySubtitle(string subtitle)
    {
        m_sSubtitleText = subtitle;
        RichTextWidget subtitleText = RichTextWidget.Cast(m_wSummaryWidget.FindAnyWidget("SubtitleText"));
        if (subtitleText)
            subtitleText.SetText(subtitle);
    }
    
    //------------------------------------------------------------------------------------------------
    void UpdateSummaryDescription(string description)
    {
        m_sDescriptionText = description;
        RichTextWidget descriptionText = RichTextWidget.Cast(m_wSummaryWidget.FindAnyWidget("DescriptionText"));
        if (descriptionText)
            descriptionText.SetText(description);
    }
 
    //------------------------------------------------------------------------------------------------
    string GetTitleText()
    {
        return m_sTitleText;
    }
 
    //------------------------------------------------------------------------------------------------
    string GetSubtitleText()
    {
        return m_sSubtitleText;
    }
    
    //------------------------------------------------------------------------------------------------
    string GetSubtitleLostText()
    {
        return m_sSubtitleLostText;
    }
    
    //------------------------------------------------------------------------------------------------
    string GetDescriptionText()
    {
        return m_sDescriptionText;
    }
}

[BaseContainerProps(), SCR_ContainerActionTitle()]
class SCR_DebriefingScreenFinishedObjectivesContent : SCR_WelcomeScreenBaseContent
{
    [Attribute()]
    protected string m_sTitleText;
    
    [Attribute(defvalue: "{0B7DDF77E24F0C63}UI/layouts/Menus/DeployMenu/DebriefingScreenFinishedObjectivesTile.layout")]
    protected ResourceName m_sFinishedObjectivesTileLayout;
    
    [Attribute(defvalue: "{6B9E63C758849B7F}UI/layouts/Menus/DeployMenu/DebriefingScreenMissionObjective.layout")]
    protected ResourceName m_sFinishedObjectivesLayout;
 
    [Attribute(defvalue: "7", desc: "Max number of objectives that can be shown on a single page", params: "1 inf")]
    protected int m_iMaxNumberOfObjectives;
    
    [Attribute(defvalue: "false", desc: "Use Task Finish History Manager for getting the list of Task Info")]
    protected bool m_bUseTaskFinishHistoryManager;
 
    protected Widget m_wFinishedObjectivesWidget;
    protected ButtonWidget m_wColumnButton;
    protected ref array<Widget> m_aFinishedObjectivesWidgets = {};
    protected int m_iCurrentPage;
    protected int m_iFinishedTasksCount;
    protected ref array<ref SCR_TaskUIInfo> m_aFinishedTasksUIInfo;
    
    //------------------------------------------------------------------------------------------------
    override void InitContent(SCR_WelcomeScreenMenu menu, string column, string columnButton)
    {
        m_sContentName = column;
        
        Widget targetTile = menu.GetRootWidget().FindAnyWidget(column);
        if (!targetTile)
                return;
        
        m_wFinishedObjectivesWidget = GetGame().GetWorkspace().CreateWidgets(m_sFinishedObjectivesTileLayout, targetTile);
        if (!m_wFinishedObjectivesWidget)
                return;
        
        Widget finishedObjectivesContent = m_wFinishedObjectivesWidget.FindAnyWidget("FinishedObjectivesLayout");
        if (!finishedObjectivesContent)
                return;
 
        m_wColumnButton = ButtonWidget.Cast(menu.GetRootWidget().FindAnyWidget(columnButton));
        if (!m_wColumnButton)
            return;
        
        FillFinishedObjectivesWidget(finishedObjectivesContent);
        InitPagination();
        HandlePagination(m_iFinishedTasksCount > m_iMaxNumberOfObjectives);
    }
    
    //------------------------------------------------------------------------------------------------
    override void ToggleInteractions(bool enabled)
    {
        HandlePagination(enabled);
    }
    
    //------------------------------------------------------------------------------------------------
    void ProcessTasks()
    {
        if (!m_aFinishedTasksUIInfo)
            m_aFinishedTasksUIInfo = {};
        else
            m_aFinishedTasksUIInfo.Clear();
 
        if (m_bUseTaskFinishHistoryManager)
        {
            int playerId = GetGame().GetPlayerController().GetPlayerId();
            array<ref SCR_TaskFinishEntry> finishedTasks = SCR_TaskFinishHistoryManagerComponent.GetInstance().GetByPlayerID(playerId);
            if (!finishedTasks)
                return;
 
            foreach (SCR_TaskFinishEntry entry : finishedTasks)
            {
                if (!entry.WasSuccessful())
                    continue;
 
                SCR_TaskUIInfo info;
                entry.GetUIInfo(info);
                m_aFinishedTasksUIInfo.Insert(info);
            }
        }
        else
        {
            SCR_TaskSystem taskSystem = SCR_TaskSystem.GetInstance();
            if (!taskSystem)
                return;
 
            SCR_FactionManager factionManager = SCR_FactionManager.Cast(GetGame().GetFactionManager());
            if (!factionManager)
                return;
 
            Faction faction = factionManager.GetLocalPlayerFaction();
            if (!faction)
                return;
 
            array<SCR_Task> completedTasks = {};
            taskSystem.GetTasksByState(completedTasks, SCR_ETaskState.COMPLETED, faction.GetFactionKey());
            foreach (SCR_Task task : completedTasks)
            {
                m_aFinishedTasksUIInfo.Insert(task.GetTaskUIInfo());
            }
        }
 
        m_iFinishedTasksCount = m_aFinishedTasksUIInfo.Count();
    }
    
    //------------------------------------------------------------------------------------------------
    void FillFinishedObjectivesWidget(Widget content)
    {
        RichTextWidget titleText = RichTextWidget.Cast(m_wFinishedObjectivesWidget.FindAnyWidget("TitleText"));
        if (titleText)
            titleText.SetText(GetTitleText());
 
        ProcessTasks();
        FlipPage(0);
 
        if (m_iFinishedTasksCount < m_iMaxNumberOfObjectives)
        {
            Widget paginationWidget = m_wFinishedObjectivesWidget.FindAnyWidget("BottomTitleSizeLayout");
            paginationWidget.SetVisible(false);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    protected void InitPagination()
    {
        Widget previousButtonWidget = m_wFinishedObjectivesWidget.FindAnyWidget("PrevButton");
        if (!previousButtonWidget)
            return;
        
        SCR_PagingButtonComponent previousButton = SCR_PagingButtonComponent.Cast(previousButtonWidget.FindHandler(SCR_PagingButtonComponent));
        if (previousButton)
            previousButton.m_OnClicked.Insert(ButtonClicked);
 
        Widget nextButtonWidget = m_wFinishedObjectivesWidget.FindAnyWidget("NextButton");
        if (!nextButtonWidget)
            return;
        
        SCR_PagingButtonComponent nextButton = SCR_PagingButtonComponent.Cast(nextButtonWidget.FindHandler(SCR_PagingButtonComponent));
        if (nextButton)
            nextButton.m_OnClicked.Insert(ButtonClicked);
    }
    
    //------------------------------------------------------------------------------------------------
    protected void ButtonClicked()
    {
        GetGame().GetWorkspace().SetFocusedWidget(m_wColumnButton);
    }
    
    //------------------------------------------------------------------------------------------------
    protected void HandlePagination(bool enabled = false)
    {
        Widget previousButtonWidget = m_wFinishedObjectivesWidget.FindAnyWidget("PrevButton");
        if (!previousButtonWidget)
            return;
        
        SCR_PagingButtonComponent previousButton = SCR_PagingButtonComponent.Cast(previousButtonWidget.FindHandler(SCR_PagingButtonComponent));
        if (!previousButton)
            return;
        
        if (enabled)
            previousButton.m_OnActivated.Insert(PreviousButtonActivated);
        else
            previousButton.m_OnActivated.Remove(PreviousButtonActivated);
 
        Widget nextButtonWidget = m_wFinishedObjectivesWidget.FindAnyWidget("NextButton");
        if (!nextButtonWidget)
            return;
        
        SCR_PagingButtonComponent nextButton = SCR_PagingButtonComponent.Cast(nextButtonWidget.FindHandler(SCR_PagingButtonComponent));
        if (!nextButton)
            return;
        
        if (enabled)
            nextButton.m_OnActivated.Insert(NextButtonActivated);
        else
            nextButton.m_OnActivated.Remove(NextButtonActivated);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void PreviousButtonActivated()
    {
        int currentPage = GetCurrentPage();
        currentPage--;
        if (currentPage < 0)
        {
            FlipPage(0);
            return;
        }
 
        FlipPage(currentPage);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void NextButtonActivated()
    {
        int currentPage = GetCurrentPage();
        currentPage++;
        if (currentPage == Math.Ceil(m_iFinishedTasksCount/6))
            return;
 
        FlipPage(currentPage);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void FlipPage(int currentPage)
    {
        int taskId;
        Widget entry;
        SCR_TaskUIInfo info;
        RichTextWidget name;
        Widget finishedObjectivesContentHolder;
        for (int i = 0; i < m_iMaxNumberOfObjectives - 1; i++)
        {
            taskId = currentPage * (m_iMaxNumberOfObjectives - 1) + i;
            if (m_aFinishedObjectivesWidgets.IsIndexValid(i))
                entry = m_aFinishedObjectivesWidgets[i];
            else
                entry = null;
 
            if (taskId >= m_iFinishedTasksCount)
            {
                if (entry)
                    entry.SetVisible(false);
 
                continue;
            }
 
            if (!entry)
            {
                if (!finishedObjectivesContentHolder)
                {
                    finishedObjectivesContentHolder = m_wFinishedObjectivesWidget.FindAnyWidget("FinishedObjectivesLayout");
                    if (!finishedObjectivesContentHolder)
                        continue;
                }
 
                entry = GetGame().GetWorkspace().CreateWidgets(m_sFinishedObjectivesLayout, finishedObjectivesContentHolder);
                m_aFinishedObjectivesWidgets.Insert(entry);
            }
 
            entry.SetVisible(true);
            name = RichTextWidget.Cast(entry.FindAnyWidget("ObjectiveText"));
            info = m_aFinishedTasksUIInfo[taskId];
            info.SetNameTo(name);
        }
        
        SetCurrentPage(currentPage);
        
        Widget pages = m_wFinishedObjectivesWidget.FindAnyWidget("Pages");
        if (!pages)
            return;
        
        SCR_SelectionHintComponent pagesVisualised = SCR_SelectionHintComponent.Cast(pages.FindHandler(SCR_SelectionHintComponent));
        if (!pagesVisualised)
            return;
        
        pagesVisualised.SetItemCount(m_iFinishedTasksCount/6);
        pagesVisualised.SetCurrentItem(currentPage);
    }
    
    //------------------------------------------------------------------------------------------------
    int GetCurrentPage()
    {
        return m_iCurrentPage;
    }
 
    //------------------------------------------------------------------------------------------------
    void SetCurrentPage(int page)
    {
        m_iCurrentPage = page;
    }
    
    //------------------------------------------------------------------------------------------------
    string GetTitleText()
    {
        return m_sTitleText;
    }
}

[BaseContainerProps(), SCR_ContainerActionTitle()]
class SCR_DebriefingScreenStatisticsContent : SCR_WelcomeScreenBaseContent
{
    [Attribute()]
    protected string m_sTitleText;
    
    [Attribute()]
    protected ref array<ref SCR_DebriefingScreenStatisticBaseClass> m_aStatistics;
    
    [Attribute(defvalue: "{64B98222099C391E}UI/layouts/Menus/DeployMenu/DebriefingScreenStatisticsTile.layout")]
    protected ResourceName m_sStatisticsTileLayout;
    
    [Attribute(defvalue: "{F2B6C48FDA2E261E}UI/layouts/Menus/DeployMenu/DebriefingScreenStatistic.layout")]
    protected ResourceName m_sStatisticsLayout;
    
    protected Widget m_wStatisticsWidget;
    
    //------------------------------------------------------------------------------------------------
    override void InitContent(SCR_WelcomeScreenMenu menu, string column, string columnButton)
    {
        m_sContentName = column;
        
        Widget targetTile = menu.GetRootWidget().FindAnyWidget(column);
        if (!targetTile)
            return;
        
        m_wStatisticsWidget = GetGame().GetWorkspace().CreateWidgets(m_sStatisticsTileLayout, targetTile);
        if (!m_wStatisticsWidget)
            return;
        
        Widget statisticsContent = m_wStatisticsWidget.FindAnyWidget("StatsLayout");
        if (!statisticsContent)
            return;
 
        FillStatisticsWidget(statisticsContent);
    }
    
    //------------------------------------------------------------------------------------------------
    void FillStatisticsWidget(Widget content)
    {
        RichTextWidget titleText = RichTextWidget.Cast(m_wStatisticsWidget.FindAnyWidget("TitleText"));
        titleText.SetText(GetTitleText());
        
        array<ref SCR_DebriefingScreenStatisticBaseClass> statistics = {};
        int statisticsCount;
        statisticsCount = GetStatistics(statistics);
        
        int statsCycleCount;
        if (statisticsCount < 7)
            statsCycleCount = statisticsCount;
        else
            statsCycleCount = 6;
        
        SCR_PlayerData playerData = GetGame().GetDataCollector().GetPlayerData(0, true, false);
        //We Calculate the stats difference only applicable for this particular session
        array<float> stats = playerData.CalculateStatsDifference();
        //Statistics are capped for 6 at the time
        for (int i = 0; i < statsCycleCount; ++i)
        {
            //statsCycleCount--;
            Widget statistic = GetGame().GetWorkspace().CreateWidgets(m_sStatisticsLayout, content);
 
            statistics[i].InitStatistic(stats);
            RichTextWidget name = RichTextWidget.Cast(statistic.FindAnyWidget("StatisticResult"));
            name.SetText(statistics[i].GetStatisticResult());
        }
    }
    
    //------------------------------------------------------------------------------------------------
    int GetStatistics(out array<ref SCR_DebriefingScreenStatisticBaseClass> statistics)
    {
        statistics = m_aStatistics;
 
        return m_aStatistics.Count();
    }
    
    //------------------------------------------------------------------------------------------------
    string GetTitleText()
    {
        return m_sTitleText;
    }
}

[BaseContainerProps()]
class SCR_DebriefingScreenStatisticBaseClass
{
    protected string m_sStatisticResult;
    
    //------------------------------------------------------------------------------------------------
    void InitStatistic(notnull array<float> stats);
    
    //------------------------------------------------------------------------------------------------
    string GetStatisticResult()
    {
        return m_sStatisticResult;
    }
}

[BaseContainerProps()]
class SCR_DebriefingScreenStatisticShotsFired : SCR_DebriefingScreenStatisticBaseClass
{
    //------------------------------------------------------------------------------------------------
    override void InitStatistic(notnull array<float> stats)
    {
        m_sStatisticResult = string.Format(WidgetManager.Translate("<b>#AR-DebriefingScreen_Statistics_Rounds</b>", Math.Floor(stats[SCR_EDataStats.SHOTS])));
    }
}

[BaseContainerProps()]
class SCR_DebriefingScreenStatisticKills : SCR_DebriefingScreenStatisticBaseClass
{
    //------------------------------------------------------------------------------------------------
    override void InitStatistic(notnull array<float> stats)
    {
        m_sStatisticResult = string.Format(WidgetManager.Translate("<b>#AR-DebriefingScreen_Statistics_Kills</b>", Math.Floor(stats[SCR_EDataStats.AI_KILLS] + stats[SCR_EDataStats.KILLS])));
    }
}

[BaseContainerProps()]
class SCR_DebriefingScreenStatisticDeaths : SCR_DebriefingScreenStatisticBaseClass
{
    //------------------------------------------------------------------------------------------------
 
    override void InitStatistic(notnull array<float> stats)
    {
        m_sStatisticResult = string.Format(WidgetManager.Translate("<b>#AR-DebriefingScreen_Statistics_Deaths</b>", Math.Floor(stats[SCR_EDataStats.DEATHS])));
    }
}

[BaseContainerProps()]
class SCR_DebriefingScreenStatisticDistanceWalked : SCR_DebriefingScreenStatisticBaseClass
{
    //------------------------------------------------------------------------------------------------
    override void InitStatistic(notnull array<float> stats)
    {
        m_sStatisticResult = string.Format(WidgetManager.Translate("<b>#AR-DebriefingScreen_Statistics_DistanceWalked</b>", Math.Floor(stats[SCR_EDataStats.DISTANCE_WALKED]/1000)));
    }
}

[BaseContainerProps()]
class SCR_DebriefingScreenStatisticDistanceDriven : SCR_DebriefingScreenStatisticBaseClass
{
    //------------------------------------------------------------------------------------------------
    override void InitStatistic(notnull array<float> stats)
    {
        m_sStatisticResult = string.Format(WidgetManager.Translate("<b>#AR-DebriefingScreen_Statistics_DistanceDriven</b>", Math.Floor(stats[SCR_EDataStats.DISTANCE_DRIVEN]/1000)));
    }
}