NotificationSystem.c

Go to the documentation of this file.

const static float NOTIFICATION_FADE_TIME = 3.0; 
 
enum NotificationType
{
  FRIEND_CONNECTED,
  INVITE_FAIL_SAME_SERVER,
  JOIN_FAIL_GET_SESSION,
  CONNECT_FAIL_GENERIC,
  DISCONNECTED,
  GENERIC_ERROR,
  //Please add types before this item
  NOTIFICATIONS_END
}
 
class NotificationRuntimeData
{
  ref NotificationData m_StaticData;
 
  float m_NotificationTime;
  float m_TimeRemaining;
  string m_DetailText;
 
  void NotificationRuntimeData(float time, NotificationData data, string detail_text)
  {
    m_NotificationTime = time;
    m_TimeRemaining = time;
    m_StaticData = data;
 
    if (detail_text != "")
      m_DetailText = detail_text;
    else
      m_DetailText = m_StaticData.m_DescriptionText;
  }
 
  float GetTime()
  {
    return m_NotificationTime;
  }
 
  float GetRemainingTime()
  {
    return m_TimeRemaining;
  }
 
  string GetIcon()
  {
    return m_StaticData.m_Icon;
  }
 
  string GetTitleText()
  {
    return m_StaticData.m_TitleText;
  }
 
  string GetDetailText()
  {
    return m_DetailText;
  }
 
  void UpdateRemainingTime(float updateInterval)
  {
    m_TimeRemaining -= updateInterval;
  }
 
  void SetTime(float time);
}
 
class NotificationSystem
{
  const int DEFAULT_TIME_DISPLAYED = 10;
  const float NOTIFICATION_FADE_TIME = 3.0;
 
  protected static const string JSON_FILE_PATH = "scripts/data/notifications.json";
  protected static const int MAX_NOTIFICATIONS = 5;
 
  private static const float UPDATE_INTERVAL_THRESHOLD = 1.0;
 
  protected static ref NotificationSystem m_Instance;
 
  protected ref array<ref NotificationRuntimeData> m_TimeArray;
  protected ref array<ref NotificationRuntimeData> m_DeferredArray;
  protected ref map<NotificationType, ref NotificationData> m_DataArray;
 
  protected float m_TimeElapsed;
 
  ref ScriptInvoker m_OnNotificationAdded = new ScriptInvoker();
  ref ScriptInvoker m_OnNotificationRemoved = new ScriptInvoker();
 
  static void InitInstance()
  {
    if (!m_Instance)
    {
      m_Instance = new NotificationSystem();
      m_Instance.LoadNotificationData();
    }
  }
 
  static void CleanupInstance()
  {
    m_Instance = null;
  }
 
  static NotificationSystem GetInstance()
  {
    return m_Instance;
  }
 
  void NotificationSystem()
  {
    m_TimeElapsed = 0.0;
 
    m_TimeArray = new array<ref NotificationRuntimeData>();
    m_DeferredArray = new array<ref NotificationRuntimeData>();
  }
 
  static void SendNotificationToPlayerExtended(Man player, float show_time, string title_text, string detail_text = "", string icon = "")
  {
    if (player)
      SendNotificationToPlayerIdentityExtended(player.GetIdentity(), show_time, title_text, detail_text, icon);
  }
 
  static void SendNotificationToPlayerIdentityExtended(PlayerIdentity player, float show_time, string title_text, string detail_text = "", string icon = "")
  {
    ScriptRPC rpc = new ScriptRPC();
 
    rpc.Write(show_time);
    rpc.Write(title_text);
    rpc.Write(detail_text);
    rpc.Write(icon);
 
    rpc.Send(null, ERPCs.RPC_SEND_NOTIFICATION_EXTENDED, true, player);
  }
 
  static void SendNotificationToPlayer(Man player, NotificationType type, float show_time, string detail_text = "")
  {
    if (player)
      SendNotificationToPlayerIdentity(player.GetIdentity(), type, show_time, detail_text);
  }
 
  static void SendNotificationToPlayerIdentity(PlayerIdentity player, NotificationType type, float show_time, string detail_text = "")
  {
    ScriptRPC rpc = new ScriptRPC();
 
    rpc.Write(type);
    rpc.Write(show_time);
    rpc.Write(detail_text);
 
    rpc.Send(null, ERPCs.RPC_SEND_NOTIFICATION, true, player);
  }
 
  static void AddNotification(NotificationType type, float show_time, string detail_text = "")
  {
    if (m_Instance.m_TimeArray.Count() < MAX_NOTIFICATIONS)
    {
      NotificationRuntimeData data = new NotificationRuntimeData(show_time, m_Instance.GetNotificationData(type), detail_text);
 
      m_Instance.m_TimeArray.Insert(data);
      m_Instance.m_OnNotificationAdded.Invoke(data);
    }
    else
    {
      NotificationRuntimeData dataDeferred = new NotificationRuntimeData(show_time, m_Instance.GetNotificationData(type), detail_text);
      m_Instance.m_DeferredArray.Insert(dataDeferred);
    }
  }
 
  static void AddNotificationExtended(float show_time, string title_text, string detail_text = "", string icon = "")
  {
    if (m_Instance.m_TimeArray.Count() < MAX_NOTIFICATIONS)
    {
      NotificationData tempData = new NotificationData(icon, title_text);
      NotificationRuntimeData data = new NotificationRuntimeData(show_time, tempData, detail_text);
 
      m_Instance.m_TimeArray.Insert(data);
      m_Instance.m_OnNotificationAdded.Invoke(data);
    }
    else
    {
      NotificationData tempDataDeferred = new NotificationData(icon, title_text);
      NotificationRuntimeData dataDeferred = new NotificationRuntimeData(show_time, tempDataDeferred, detail_text);
      m_Instance.m_DeferredArray.Insert(dataDeferred);
    }
  }
 
  static void Update(float timeslice)
  {
    if (m_Instance)
    {
      if (g_Game.GetGameState() != DayZGameState.IN_GAME && g_Game.GetGameState() != DayZGameState.MAIN_MENU)
        return;
 
      m_Instance.m_TimeElapsed += timeslice;
      if (m_Instance.m_TimeElapsed >= UPDATE_INTERVAL_THRESHOLD)
      {
        array<NotificationRuntimeData> expiredNotifications = new array<NotificationRuntimeData>();
        foreach (NotificationRuntimeData visibleNotificationData : m_Instance.m_TimeArray)
        {
          if (visibleNotificationData.GetRemainingTime() <= 0.0)
            expiredNotifications.Insert(visibleNotificationData);
          else
            visibleNotificationData.UpdateRemainingTime(UPDATE_INTERVAL_THRESHOLD);
        }
 
        foreach (NotificationRuntimeData expiredNotificationData : expiredNotifications)
        {
          m_Instance.m_OnNotificationRemoved.Invoke(expiredNotificationData);
          m_Instance.m_TimeArray.RemoveItem(expiredNotificationData);
 
          if (m_Instance.m_DeferredArray.Count() > 0)
          {
            int count = m_Instance.m_DeferredArray.Count();
            NotificationRuntimeData deferredNotificationData = m_Instance.m_DeferredArray.Get(count - 1);
            m_Instance.m_TimeArray.Insert(deferredNotificationData);
            m_Instance.m_OnNotificationAdded.Invoke(deferredNotificationData);
            m_Instance.m_DeferredArray.Remove(count - 1);
          }
        }
 
        m_Instance.m_TimeElapsed = 0;
      }
    }
  }
 
  protected NotificationData GetNotificationData(NotificationType type)
  {
    if (m_DataArray.Contains(type))
      return m_DataArray.Get(type);
 
    return null;
  }
 
  static void LoadNotificationData()
  {
    map<NotificationType, NotificationData> dataArray;
    m_Instance.m_DataArray = new map<NotificationType, ref NotificationData>();
    string errorMessage;
    if (!JsonFileLoader<map<NotificationType, NotificationData>>.LoadFile(JSON_FILE_PATH, dataArray, errorMessage))
      ErrorEx(errorMessage);
 
    m_Instance.m_DataArray.Copy(dataArray);
 
    array<int> notificationTypes = new array<int>();
    NotificationType notificationType = 0;
    while (notificationType != NotificationType.NOTIFICATIONS_END)
    {
      notificationTypes.Insert(notificationType);
      notificationType++;
    }
 
    for (int i = 0; i < m_Instance.m_DataArray.Count(); ++i)
      notificationTypes.RemoveItem(m_Instance.m_DataArray.GetKey(i));
 
    if (notificationTypes.Count() > 0)
    {
      foreach (NotificationType notificationType2 : notificationTypes)
      {
        NotificationData notificationData = new NotificationData(
          "please_add_an_icon",
          "please_add_a_title",
          "optional_description",
        );
 
        m_Instance.m_DataArray.Insert(notificationType2, notificationData);
      }
 
      if (!JsonFileLoader<map<NotificationType, ref NotificationData>>.SaveFile(JSON_FILE_PATH, m_Instance.m_DataArray, errorMessage))
        ErrorEx(errorMessage);
    }
  }
}