SCR_NotificationSenderComponent.c

Go to the documentation of this file.

[ComponentEditorProps(category: "GameScripted/GameMode/Components", description: "Base for gamemode scripted component.")]
class SCR_NotificationSenderComponentClass : SCR_BaseGameModeComponentClass
{
}
 
class SCR_NotificationSenderComponent : SCR_BaseGameModeComponent
{       
    [Attribute("1", desc: "Show player left notification if player left.")]
    protected bool m_bShowPlayerLeftNotification;
    
    [Attribute("10", desc: "Is killfeed enabled and what info will be displayed (Full killfeed is always displayed in open unlimited Editor)", uiwidget: UIWidgets.ComboBox, enums: ParamEnumArray.FromEnum(EKillFeedType))]
    protected EKillFeedType m_iKillFeedType;
    
    [Attribute("40", desc: "If killfeed is enabled, what is the relationship between the player that died and the local player. (Full killfeed is always displayed in open unlimited Editor)", uiwidget: UIWidgets.ComboBox, enums: ParamEnumArray.FromEnum(EKillFeedReceiveType))]
    protected EKillFeedReceiveType m_iReceiveKillFeedType;
    
    [Attribute("0", desc: "Array of Killfeed names")]
    protected ref array<ref SCR_NotificationKillfeedTypeName> m_aKillfeedTypeNames;
    
    [Attribute("0", desc: "Array of Killfeed receive names")]
    protected ref array<ref SCR_NotificationKillfeedreceiveTypeName> m_aKillfeedReceiveTypeNames;
    
    [Attribute("{D3BFEE28E7D5B6A1}Configs/ServerBrowser/KickDialogs.conf", desc: "If disconnect reason has a preset set to it then it will send a kick/ban notification", params: "conf")]
    protected ref SCR_ConfigurableDialogUiPresets m_PlayerKickReasonsConfig;
    
    protected Faction m_FactionOnSpawn;
    
    protected SCR_FactionManager m_FactionManager;
    
    //States
    protected bool m_bListeningToWeatherChanged;
    
    //------------------------------------------------------------------------------------------------
    override void OnControllableDestroyed(IEntity entity, IEntity killerEntity, notnull Instigator killer)
    {
        //~ hot fix for On Controllable Destroyed issues \/
        if (Replication.IsClient())
            return;
        
        if (!entity)
            return;
        
        RplComponent entityRpl = RplComponent.Cast(entity.FindComponent(RplComponent));
        RplComponent instigatorRpl;
        
        if (killerEntity)
            instigatorRpl = RplComponent.Cast(killerEntity.FindComponent(RplComponent));
        
        RplId entityRplId = RplId.Invalid();
        RplId instigatorRplId = RplId.Invalid();
        
        if (entityRpl)
            entityRplId = entityRpl.Id();
        
        if (instigatorRpl)
            instigatorRplId = instigatorRpl.Id();
        
        OnControllableDestroyedBroadCast(entityRplId, instigatorRplId);
        Rpc(OnControllableDestroyedBroadCast, entityRplId,instigatorRplId);
        
        //~ hot fix for On Controllable Destroyed issues /\
    }
    
    //------------------------------------------------------------------------------------------------
    //~ Todo: This is a hot a hotfix for On Controllable Destroyed issues \/
    [RplRpc(RplChannel.Reliable, RplRcver.Broadcast)]
    protected void OnControllableDestroyedBroadCast(RplId entityRplId, RplId instigatorRplId)
    {
        IEntity entity;
        IEntity instigator;
        
        RplComponent entityRpl = RplComponent.Cast(Replication.FindItem(entityRplId));
        RplComponent instigatorRpl = RplComponent.Cast(Replication.FindItem(instigatorRplId));
        
        if (entityRpl)
            entity = entityRpl.GetEntity();
        
        if (instigatorRpl)
            instigator = instigatorRpl.GetEntity();
        
        OnControllableDestroyedHotfix(entity, instigator);
    }
    //~ hot fix for On Controllable Destroyed  issues /\
    
    //------------------------------------------------------------------------------------------------
    //~ Todo: hot fix for On Controllable Destroyed  issues - Move logic to OnControllableDestroyed if fixed
    protected void OnControllableDestroyedHotfix(IEntity entity, IEntity instigator)
    {       
        //~ No entity destroyed
        if (!entity)
            return;
        
        bool isUnlimitedEditorOpened = false;
        
        //~ Check if player has unlimited editor and if the editor is open
        SCR_EditorManagerEntity editorManager = SCR_EditorManagerEntity.GetInstance();
        if (editorManager)
            isUnlimitedEditorOpened = !editorManager.IsLimited() && editorManager.IsOpened();
        
        //~ Killfeed is disabled and unlimited editor is not open
        if (!isUnlimitedEditorOpened && m_iKillFeedType == EKillFeedType.DISABLED)
            return;
        
        int playerId = SCR_PossessingManagerComponent.GetPlayerIdFromControlledEntity(entity);
        if (playerId <= 0)
            return;
        
        //~ Check if killed player message can be seen if Limited editor (or editor not open)
        if (!isUnlimitedEditorOpened && m_iReceiveKillFeedType != EKillFeedReceiveType.ALL)
        {
            //~ No faction manager so don't show killfeed?
            if (!m_FactionManager)
                return;
            
            Faction localPlayerFaction = m_FactionManager.GetLocalPlayerFaction();
 
            //~ No local faction so don't show killfeed
            if (!localPlayerFaction)
                return;
            
            int localPlayerID = SCR_PlayerController.GetLocalPlayerId();
            Faction killedPlayerFaction = m_FactionManager.GetPlayerFaction(playerId);
            
            switch (m_iReceiveKillFeedType)
            {
                //~ check if in group
                case EKillFeedReceiveType.GROUP_ONLY :
                {
                    //~ Check if local player is not the same as killed otherwise they are always in the same group
                    if (localPlayerID != playerId)
                    {
                        //~ Factions not friendly so don't show killfeed
                        if (!localPlayerFaction.IsFactionFriendly(killedPlayerFaction))
                            return;
                        
                        //~ No group manager so don't send
                        SCR_GroupsManagerComponent groupManager = SCR_GroupsManagerComponent.GetInstance();
                        if (!groupManager)
                            return;
                        
                        SCR_AIGroup localPlayerGroup = groupManager.GetPlayerGroup(localPlayerID);
                        
                        //~ If not in group or not in the same group do not send
                        if (!localPlayerGroup || !localPlayerGroup.IsPlayerInGroup(playerId))
                            return;
                    }
                    
                    break;
                }
 
                //~ Check if the same faction
                case EKillFeedReceiveType.SAME_FACTION_ONLY :
                {
                    //~ Check if local player is not the same as killed otherwise they are always the same faction
                    if (localPlayerID != playerId)
                    {
                        //~ If no local faction or if not the same faction do not show killfeed
                        if (!localPlayerFaction || localPlayerFaction != killedPlayerFaction)
                            return;
                        
                        //~ If Faction is hostile towards itself still do not show killfeed (DM)
                        if (!localPlayerFaction.IsFactionFriendly(localPlayerFaction))
                            return;
                    }
                    
                    break;
                }
 
                //~ Check if allies
                case EKillFeedReceiveType.ALLIES_ONLY :
                {
                    //~ Check if local player is not the same as killed otherwise they are always allied
                    if (localPlayerID != playerId)
                    {
                        //~ Factions not friendly so don't show killfeed
                        if (!localPlayerFaction || !localPlayerFaction.IsFactionFriendly(killedPlayerFaction))
                            return;
                    }
                    
                    break;
                }
 
                //~ Check if enemies
                case EKillFeedReceiveType.ENEMIES_ONLY :
                {
                    //~ If local player killed it is never an enemy
                    if (localPlayerID == playerId)
                        return;
                    
                    //~ Factions friendly so don't show killfeed
                    if (localPlayerFaction.IsFactionFriendly(killedPlayerFaction))
                        return;
                    
                    break;
                }
            }
        }
        
        //~ Never show killer so simply show player died if limited editor
        if (!isUnlimitedEditorOpened && m_iKillFeedType == EKillFeedType.UNKNOWN_KILLER)
        {
            SCR_NotificationsComponent.SendLocal(ENotification.PLAYER_DIED, playerId);
            return;
        }
        
        int killerId;
        if (entity == instigator)
            killerId = playerId;
        else 
            killerId = SCR_PossessingManagerComponent.GetPlayerIdFromControlledEntity(instigator);
 
        SCR_EditableCharacterComponent killerEditableCharacterComponent;
        //~ If there is a killer and the killer is not the player itself
        if (instigator && killerId <= 0)
        {
            killerEditableCharacterComponent = SCR_EditableCharacterComponent.Cast(instigator.FindComponent(SCR_EditableCharacterComponent));
        
            //~ Killer was not character so get killer in vehicle
            if (!killerEditableCharacterComponent)
                killerEditableCharacterComponent = GetKillerFromVehicle(instigator, instigator.IsInherited(Vehicle));
            
            if (killerEditableCharacterComponent)
                killerId = SCR_PossessingManagerComponent.GetPlayerIdFromControlledEntity(killerEditableCharacterComponent.GetOwner());
        }
 
        bool playerIsPossessed = false; 
        bool killerIsPossessed = false; 
        
        //~ Check if player or killer where possessed
        SCR_PossessingManagerComponent possesionManager = SCR_PossessingManagerComponent.GetInstance();
        if (possesionManager)
        {
            playerIsPossessed = possesionManager.IsPossessing(playerId);
            
            if (killerId > 0)
                killerIsPossessed = possesionManager.IsPossessing(killerId);
        }
 
        //Death notification    
        //Suicide   
        if (playerId == killerId || !instigator)
        {           
            //Player Suicide
            if (!playerIsPossessed)
                SCR_NotificationsComponent.SendLocal(ENotification.PLAYER_DIED, playerId);
            //Possessed Suicide
            else 
                SCR_NotificationsComponent.SendLocalUnlimitedEditor(ENotification.POSSESSED_AI_DIED, playerId);
        }
        //If killed by other player
        else if (killerId > 0)
        {
            //Player killed player
            if (!playerIsPossessed && !killerIsPossessed)
            {
                SCR_NotificationsComponent.SendLocal(ENotification.PLAYER_KILLED_PLAYER, killerId, playerId);
            }
            //Possesed player killed by other player (Show player killed by NPC and for GM: possesed GM killed player)
            else if (!playerIsPossessed && killerIsPossessed)
            {       
                SCR_NotificationsComponent.SendLocalUnlimitedEditor(ENotification.POSSESSED_AI_KILLED_PLAYER, killerId, playerId);
                SCR_NotificationsComponent.SendLocalLimitedEditor(ENotification.AI_KILLED_PLAYER, killerId, playerId);
            }
            //Player killed possessed player (Show to GM only)
            else if (playerIsPossessed && !killerIsPossessed)
            {
                SCR_NotificationsComponent.SendLocalUnlimitedEditor(ENotification.PLAYER_KILLED_POSSESSED_AI, killerId, playerId);
            }
            //Possessed AI Killed Possessed AI (GM Only)
            else
            {
                SCR_NotificationsComponent.SendLocalUnlimitedEditor(ENotification.POSSESSED_AI_KILLED_POSSESSED_AI, killerId, playerId);
            }
        }
        //Killed by NPC
        else if (killerEditableCharacterComponent)
        {
            int killerRplId = Replication.FindId(killerEditableCharacterComponent);
            
            if (!playerIsPossessed)
                SCR_NotificationsComponent.SendLocal(ENotification.AI_KILLED_PLAYER, killerRplId, playerId);
            else 
                SCR_NotificationsComponent.SendLocalUnlimitedEditor(ENotification.AI_KILLED_POSSESSED_AI, killerRplId, playerId);
        }
        //Unknown killer
        else 
        {
            if (!playerIsPossessed)
                SCR_NotificationsComponent.SendLocal(ENotification.PLAYER_DIED, playerId);
            else 
                SCR_NotificationsComponent.SendLocalUnlimitedEditor(ENotification.POSSESSED_AI_DIED, playerId);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    protected SCR_EditableCharacterComponent GetKillerFromVehicle(IEntity veh, bool pilot)
    {
        BaseCompartmentManagerComponent compartmentManager = BaseCompartmentManagerComponent.Cast(veh.FindComponent(BaseCompartmentManagerComponent));
            
        if (!compartmentManager)
            return null;
        
        array<BaseCompartmentSlot> compartments = {};
        
        for (int i = 0, compart = compartmentManager.GetCompartments(compartments); i < compart; i++)
        {
            BaseCompartmentSlot slot = compartments[i];
            
            if (pilot && slot.Type() == PilotCompartmentSlot)
            {
                if (slot.GetOccupant())
                    return SCR_EditableCharacterComponent.Cast(slot.GetOccupant().FindComponent(SCR_EditableCharacterComponent));
            }
            else if (!pilot && slot.Type() == TurretCompartmentSlot)
            {
                if (slot.GetOccupant())
                    return SCR_EditableCharacterComponent.Cast(slot.GetOccupant().FindComponent(SCR_EditableCharacterComponent));
            }
        }
        
        return null;
    }
    
    //------------------------------------------------------------------------------------------------
    protected void OnEditorLimitedChanged(bool isLimited)
    {
        SCR_EditorManagerEntity editorManager = SCR_EditorManagerEntity.GetInstance();
        if (!editorManager) 
            return;
        
        int playerID = editorManager.GetPlayerID();
        
        //Became Player
        if (isLimited)
            SCR_NotificationsComponent.SendToEveryone(ENotification.EDITOR_PLAYER_NO_LONGER_GM, playerID);
        //Became GM
        else 
            SCR_NotificationsComponent.SendToEveryone(ENotification.EDITOR_PLAYER_BECAME_GM, playerID);
    }
    
    //------------------------------------------------------------------------------------------------
    override void OnPlayerRegistered(int playerId) 
    {
        //Join notification
        SCR_NotificationsComponent.SendLocal(ENotification.PLAYER_JOINED, playerId);
    }
    
    //------------------------------------------------------------------------------------------------
    override void OnPlayerDisconnected(int playerId, KickCauseCode cause, int timeout) 
    {
        //~ Should never be called for clients but just in case
        if (!GetGameMode().IsMaster())
            return;
        
        SCR_EditorManagerEntity editorManager;
        
        //~ Get editorManager if has any
        SCR_EditorManagerCore core = SCR_EditorManagerCore.Cast(SCR_EditorManagerCore.GetInstance(SCR_EditorManagerCore));
        if (core)
            editorManager = core.GetEditorManager(playerId);
 
        bool hasUnlimitedEditor = editorManager && !editorManager.IsLimited();
        
        //~ Is GM, Always show GM left notification even if kicked/banned to notify players that the GM has left
        if (hasUnlimitedEditor)
            SCR_NotificationsComponent.SendToEveryone(ENotification.EDITOR_GM_LEFT, playerId);      
        
        bool isKickedOrBanned = false;
        
        //~ Check if disconnect cause has message attached to it. If true: show kick/ban reason. If false: only show gm/player left
        if (m_PlayerKickReasonsConfig)
        {
            string groupId, reasonId;
            KickCauseGroup2 groupInt;
            int reasonInt;
            
            //~ Get disconnect message preset
            GetGame().GetFullKickReason(cause, groupInt, reasonInt, groupId, reasonId);
            SCR_ConfigurableDialogUiPreset preset = m_PlayerKickReasonsConfig.FindPreset(groupId + "_" + reasonId);
            
            //~ If has kick/Ban message it will send out a notification
            isKickedOrBanned = preset != null && !preset.m_sMessage.IsEmpty();
        }
        //~ No config
        else 
        {
            Print("'SCR_NotificationSenderComponent' has no 'm_PlayerKickReasonsConfig'! Make sure it is added else it will never know if a player was kicked!", LogLevel.ERROR);
        }
        
        //~ Is kicked/banned. Will also send ban notification if for some reason there is a timeout attached even if there is no specific kick message
        if (isKickedOrBanned || timeout != 0)
        {
            SCR_DataCollectorComponent dataCollector = GetGame().GetDataCollector();
            if (dataCollector)
            {
                SCR_PlayerData playerData = dataCollector.GetPlayerData(playerId);
                
                if (playerData)
                {
                    float banTimeOut = playerData.GetTimeOut();
                
                    //~ If playerData has ban timeout which is greater then timeout use that instead. This is because Heavy ban kicks the player and bans it via backend. So the timeout is set somewhere else
                    if (banTimeOut > 0 && banTimeOut > timeout)
                        timeout = banTimeOut;
                }
            }
            
            //~ Player kicked 
            if (timeout == 0)
                SCR_NotificationsComponent.SendToEveryone(ENotification.PLAYER_KICKED, playerId, cause, timeout);   
            //~ Player perminent ban
            else if (timeout < 0)
                SCR_NotificationsComponent.SendToEveryone(ENotification.PLAYER_BANNED_NO_DURATION, playerId, cause, timeout);
            //~ Player temp ban
            else
                SCR_NotificationsComponent.SendToEveryone(ENotification.PLAYER_BANNED, playerId, cause, timeout);
        }       
        //~ Is Not kicked/banned, is player and should send on leave notification. 
        else if (m_bShowPlayerLeftNotification && !hasUnlimitedEditor)
        {
            SCR_NotificationsComponent.SendToEveryone(ENotification.PLAYER_LEFT, playerId);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    override void OnPlayerSpawned(int playerId, IEntity controlledEntity)
    {
        //Check if faction changed and send notification if diffrent
        if (m_FactionManager) 
        {
            //Get factions using ID
            Faction playerFaction = m_FactionManager.GetPlayerFaction(playerId);
        
            //Faction is diffrent
            if (m_FactionOnSpawn != playerFaction)
            {
                //Send player joined faction notification
                SCR_NotificationsComponent.SendToUnlimitedEditorPlayers(ENotification.PLAYER_JOINED_FACTION, playerId);
                m_FactionOnSpawn = playerFaction;
            }
        }
    }   
 
    //======================================== WEATHER SET TO LOOPING ========================================\\
 
    //------------------------------------------------------------------------------------------------
    void OnWeatherChangedNotification(int playerID)
    {
        if (Replication.IsClient())
            return;
        
        if (!m_bListeningToWeatherChanged)
        {
            m_bListeningToWeatherChanged = true;
            GetGame().GetCallqueue().CallLater(OnWeatherChangedNotificationDelay, 0 , false, playerID);
        }
    }
    
    //------------------------------------------------------------------------------------------------
    protected void OnWeatherChangedNotificationDelay(int playerID)
    {
        m_bListeningToWeatherChanged = false;
        
        ChimeraWorld world = ChimeraWorld.CastFrom(GetGame().GetWorld());
        if (!world) 
            return;
        
        TimeAndWeatherManagerEntity weatherManager = world.GetTimeAndWeatherManager();
        if (!weatherManager) 
            return;
        
        WeatherState currentState = weatherManager.GetCurrentWeatherState();
        
        if (!currentState)
            return;
        
        SCR_NotificationsComponent.SendToUnlimitedEditorPlayers(ENotification.EDITOR_ATTRIBUTES_WEATHER_CHANGED, playerID, currentState.GetStateID());
    }
    
    //======================================== KILLFEED ========================================\\  
 
    //------------------------------------------------------------------------------------------------
    int GetKillFeedTypeNames(notnull array<ref SCR_NotificationKillfeedTypeName> killFeedTypeNames)
    {
        killFeedTypeNames.Clear();
        foreach (SCR_NotificationKillfeedTypeName killfeedTypeName: m_aKillfeedTypeNames)
        {
            killFeedTypeNames.Insert(killfeedTypeName);
        }
        
        return killFeedTypeNames.Count();
    }
    
    //------------------------------------------------------------------------------------------------
    int GetKillFeedReceiveTypeNames(notnull array<ref SCR_NotificationKillfeedreceiveTypeName> killFeedReceiveTypeNames)
    {
        killFeedReceiveTypeNames.Clear();
        foreach (SCR_NotificationKillfeedreceiveTypeName killfeedReceiveTypeName: m_aKillfeedReceiveTypeNames)
        {
            killFeedReceiveTypeNames.Insert(killfeedReceiveTypeName);
        }
        
        return killFeedReceiveTypeNames.Count();
    }
    
    //------------------------------------------------------------------------------------------------
    EKillFeedType GetKillFeedType()
    {
        return m_iKillFeedType;
    }
    
    //------------------------------------------------------------------------------------------------
    void SetKillFeedType(EKillFeedType killFeedType, int playerNotificationId = -1)
    {
        if (!GetGameMode().IsMaster() || killFeedType == m_iKillFeedType)
            return;
        
        SetKillFeedTypeBroadcast(killFeedType);
        Rpc(SetKillFeedTypeBroadcast, killFeedType);
        
        if (playerNotificationId > 0)
            SCR_NotificationsComponent.SendToEveryone(ENotification.EDITOR_CHANGED_KILLFEED_TYPE, playerNotificationId, killFeedType, false);
    }
    
    //------------------------------------------------------------------------------------------------
    EKillFeedReceiveType GetReceiveKillFeedType()
    {
        return m_iReceiveKillFeedType;
    }
    
    //------------------------------------------------------------------------------------------------
    void SetReceiveKillFeedType(EKillFeedReceiveType receiveKillFeedType, int playerNotificationId = -1)
    {
        if (receiveKillFeedType == m_iReceiveKillFeedType || !GetGameMode().IsMaster())
            return;
        
        SetReceiveKillFeedTypeBroadcast(receiveKillFeedType);
        Rpc(SetReceiveKillFeedTypeBroadcast, receiveKillFeedType);
        
        if (playerNotificationId > 0)
            SCR_NotificationsComponent.SendToEveryone(ENotification.EDITOR_CHANGED_KILLFEED_RECEIVE_TYPE, playerNotificationId, receiveKillFeedType, true);
    }
    
    //------------------------------------------------------------------------------------------------
    [RplRpc(RplChannel.Reliable, RplRcver.Broadcast)]
    protected void SetKillFeedTypeBroadcast(EKillFeedType killFeedType)
    {
        m_iKillFeedType = killFeedType;
    }
    
    //------------------------------------------------------------------------------------------------
    [RplRpc(RplChannel.Reliable, RplRcver.Broadcast)]
    protected void SetReceiveKillFeedTypeBroadcast(EKillFeedReceiveType receiveKillFeedType)
    {
        m_iReceiveKillFeedType = receiveKillFeedType;
    }
    
    //======================================== RPL ========================================\\
 
    //------------------------------------------------------------------------------------------------
    override bool RplSave(ScriptBitWriter writer)
    {
        writer.WriteInt(m_iKillFeedType);
        writer.WriteInt(m_iReceiveKillFeedType);
        
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    override bool RplLoad(ScriptBitReader reader)
    {
        EKillFeedType killFeedType;
        EKillFeedReceiveType receiveKillFeedType;
        
        reader.ReadInt(killFeedType);
        reader.ReadInt(receiveKillFeedType);
 
        SetKillFeedTypeBroadcast(killFeedType);
        SetReceiveKillFeedTypeBroadcast(receiveKillFeedType);
        
        return true;
    }
    
    //======================================== INIT ========================================\\
 
    //------------------------------------------------------------------------------------------------
    override void EOnInit(IEntity owner)
    {
        SCR_EditorManagerEntity editorManager = SCR_EditorManagerEntity.GetInstance();
        if (editorManager)
            editorManager.GetOnLimitedChange().Insert(OnEditorLimitedChanged);
        
        m_FactionManager = SCR_FactionManager.Cast(GetGame().GetFactionManager());
        
        super.EOnInit(owner);
    }
    
    //------------------------------------------------------------------------------------------------
    override void OnPostInit(IEntity owner)
    {
        SetEventMask(owner, EntityEvent.INIT);
        
        super.OnPostInit(owner);
    }
    
    //======================================== DELETE ========================================\\
 
    //------------------------------------------------------------------------------------------------
    protected override void OnDelete(IEntity owner)
    {
        SCR_EditorManagerEntity editorManager = SCR_EditorManagerEntity.GetInstance();
        if (editorManager)
            editorManager.GetOnLimitedChange().Remove(OnEditorLimitedChanged);
        
        super.OnDelete(owner);
    }
}
 
enum EKillFeedType
{
    //~ If changes are made in this enum make sure to change m_aKillfeedTypeNames
    DISABLED = 0,           
    UNKNOWN_KILLER = 10,    
    FULL = 20,              
}
 
enum EKillFeedReceiveType
{
    //~ If changes are made in this enum make sure to change m_aKillfeedReceiveTypeNames
    ALL = 0,                
    ENEMIES_ONLY = 10,      
    ALLIES_ONLY = 20,       
    SAME_FACTION_ONLY = 30, 
    GROUP_ONLY = 40,        
}
 
[BaseContainerProps(), SCR_BaseContainerCustomTitleEnum(EKillFeedType, "m_iKillfeedType")]
class SCR_NotificationKillfeedTypeName
{
    [Attribute(desc: "Killfeed type", uiwidget : UIWidgets.ComboBox, enums: ParamEnumArray.FromEnum(EKillFeedType))]
    protected EKillFeedType m_iKillfeedType;
    
    [Attribute(desc: "Name displayed in Notification", uiwidget: UIWidgets.LocaleEditBox)]
    protected LocalizedString m_sKillfeedTypeName;
    
    //------------------------------------------------------------------------------------------------
    EKillFeedType GetKillfeedType()
    {
        return m_iKillfeedType;
    }
    
    //------------------------------------------------------------------------------------------------
    string GetName()
    {
        return m_sKillfeedTypeName;
    }
}
 
[BaseContainerProps(), SCR_BaseContainerCustomTitleEnum(EKillFeedReceiveType, "m_iKillfeedreceiveType")]
class SCR_NotificationKillfeedreceiveTypeName
{
    [Attribute(desc: "Killfeed receive type", uiwidget : UIWidgets.ComboBox, enums: ParamEnumArray.FromEnum(EKillFeedReceiveType))]
    protected EKillFeedReceiveType m_iKillfeedreceiveType;
    
    [Attribute(desc: "Name displayed in Notification", uiwidget: UIWidgets.LocaleEditBox)]
    protected LocalizedString m_sKillfeedReceiveTypeName;
    
    //------------------------------------------------------------------------------------------------
    EKillFeedType GetKillfeedReceiveType()
    {
        return m_iKillfeedreceiveType;
    }
    
    //------------------------------------------------------------------------------------------------
    string GetName()
    {
        return m_sKillfeedReceiveTypeName;
    }
}