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);
 }
 }
}