dayzgame.c

Go to the documentation of this file.

enum DisconnectSessionFlags
{
 NONE = 0,
 JOIN_ERROR_ENABLED = 1,
 JOIN_ERROR_CHECK = 2,
 DISCONNECT_ERROR_ENABLED = 4,
 SELECT_USER = 8,
 CLOSE_MENUS = 16,
 IGNORE_WHEN_IN_GAME = 32,
 ALWAYS_FORCE = 64,
}
 
const int DISCONNECT_SESSION_FLAGS_FORCE = int.MAX & ~DisconnectSessionFlags.IGNORE_WHEN_IN_GAME;
const int DISCONNECT_SESSION_FLAGS_JOIN = int.MAX & ~DisconnectSessionFlags.JOIN_ERROR_CHECK;
const int DISCONNECT_SESSION_FLAGS_ALL = int.MAX;
 
class ProjectileStoppedInfo : Managed
{
 proto native Object GetSource();
 proto native vector GetPos();
 proto native vector GetInVelocity();
 proto native string GetAmmoType();
 proto native float GetProjectileDamage();
}
 
class CollisionInfoBase: ProjectileStoppedInfo
{
 proto native vector GetSurfNormal();
}
 
class ObjectCollisionInfo: CollisionInfoBase
{
 proto native Object GetHitObj();
 proto native vector GetHitObjPos();
 proto native vector GetHitObjRot();
 proto native int GetComponentIndex();
}
 
class TerrainCollisionInfo: CollisionInfoBase
{
 proto native bool GetIsWater();
}
 
class CrashSoundSets
{
 static ref map<int, string> m_Mappings = new map<int, string>;
 
 static void RegisterSoundSet(string sound_set)
 {
 m_Mappings.Set(sound_set.Hash(), sound_set);
 }
 
 static string GetSoundSetByHash(int hash)
 {
 string sound_set;
 if (m_Mappings)
 m_Mappings.Find(hash,sound_set);
 return sound_set;
 }
};
 
 
class LoginScreenBase extends UIScriptedMenu
{
 protected ref UiHintPanelLoading m_HintPanel;
 protected bool m_IsStatic;
 protected float m_HintTimeAccu;
 
 override void Update(float timeslice)
 {
 if (m_HintPanel)
 {
 m_HintTimeAccu += timeslice;
 if (CanChangeHintPage(m_HintTimeAccu))
 {
 m_HintPanel.ShowRandomPage();
 m_HintTimeAccu = 0;
 }
 }
 
 if (GetUApi().GetInputByID(UAUIBack).LocalPress())
 {
 Leave();
 }
 }
 
 protected void Leave()
 {
 g_Game.SetGameState(DayZGameState.MAIN_MENU);
 g_Game.SetLoadState(DayZLoadState.MAIN_MENU_START);
 
 g_Game.GetCallQueue(CALL_CATEGORY_SYSTEM).Call(GetGame().DisconnectSessionForce);
 
 Close();
 }
 
 protected bool CanChangeHintPage(float timeAccu);
 
 bool IsStatic()
 {
 return m_IsStatic;
 }
}
 
class LoginQueueBase extends LoginScreenBase
{
 protected TextWidget m_txtPosition;
 protected TextWidget m_txtNote;
 protected ButtonWidget m_btnLeave;
 protected int m_iPosition = -1;
 
 void LoginQueueBase()
 { 
 g_Game.SetKeyboardHandle(this); 
 }
 
 void ~LoginQueueBase()
 {
 g_Game.SetKeyboardHandle(NULL); 
 }
 
 override Widget Init()
 { 
 layoutRoot = GetGame().GetWorkspace().CreateWidgets("gui/layouts/dialog_queue_position.layout");
 m_HintPanel = new UiHintPanelLoading(layoutRoot.FindAnyWidget("hint_frame0"));
 m_txtPosition = TextWidget.Cast(layoutRoot.FindAnyWidget("txtPosition"));
 m_txtNote = TextWidget.Cast(layoutRoot.FindAnyWidget("txtNote"));
 m_btnLeave = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btnLeave"));
 m_txtNote.Show(true);
 layoutRoot.FindAnyWidget("notification_root").Show(false);
 
 #ifdef PLATFORM_CONSOLE
 layoutRoot.FindAnyWidget("toolbar_bg").Show(true);
 RichTextWidget toolbar_b = RichTextWidget.Cast(layoutRoot.FindAnyWidget("BackIcon"));
 toolbar_b.SetText(InputUtils.GetRichtextButtonIconFromInputAction("UAUIBack", "", EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 #ifdef PLATFORM_XBOX
 #ifdef BUILD_EXPERIMENTAL
 layoutRoot.FindAnyWidget("notification_root").Show(true);
 #endif
 #endif
 #endif
 
 return layoutRoot;
 }
 
 override bool OnClick(Widget w, int x, int y, int button)
 {
 super.OnClick(w, x, y, button);
 if (w == m_btnLeave)
 {
 Leave();
 return true;
 }
 return false;
 }
 
 void Show()
 {
 if (layoutRoot)
 {
 layoutRoot.Show(true);
 }
 }
 
 void Hide()
 {
 if (layoutRoot)
 layoutRoot.Show(false);
 m_HintPanel = null;
 }
 
 void SetPosition(int position)
 {
 if (position != m_iPosition)
 {
 m_iPosition = position;
 m_txtPosition.SetText(position.ToString());
 }
 }
 
 override protected bool CanChangeHintPage(float timeAccu)
 {
 return timeAccu >= GameConstants.LOADING_SCREEN_HINT_INTERVAL;
 }
};
 
 
class LoginQueueStatic extends LoginQueueBase
{
 void LoginQueueStatic()
 {
 Init();
 
 m_IsStatic = true;
 }
};
 
class LoginTimeBase extends LoginScreenBase
{
 protected TextWidget m_txtDescription;
 protected TextWidget m_txtLabel;
 protected ButtonWidget m_btnLeave;
 
 protected bool m_IsRespawn;
 
 private ref FullTimeData m_FullTime;
 
 void LoginTimeBase()
 {
 g_Game.SetKeyboardHandle(this);
 m_IsRespawn = false;
 
 m_FullTime = new FullTimeData();
 }
 
 void ~LoginTimeBase()
 {
 if (g_Game)
 g_Game.SetKeyboardHandle(null);
 m_FullTime = null;
 }
 
 override Widget Init()
 {
 layoutRoot = GetGame().GetWorkspace().CreateWidgets("gui/layouts/dialog_login_time.layout");
 
 m_txtDescription = TextWidget.Cast(layoutRoot.FindAnyWidget("txtDescription"));
 m_txtLabel = TextWidget.Cast(layoutRoot.FindAnyWidget("txtLabel"));
 m_btnLeave = ButtonWidget.Cast(layoutRoot.FindAnyWidget("btnLeave"));
 m_txtDescription.Show(true);
 layoutRoot.FindAnyWidget("notification_root").Show(false);
 
 #ifdef PLATFORM_CONSOLE
 layoutRoot.FindAnyWidget("toolbar_bg").Show(true);
 RichTextWidget toolbar_b = RichTextWidget.Cast(layoutRoot.FindAnyWidget("BackIcon"));
 toolbar_b.SetText(InputUtils.GetRichtextButtonIconFromInputAction("UAUIBack", "", EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 #ifdef PLATFORM_XBOX
 #ifdef BUILD_EXPERIMENTAL
 layoutRoot.FindAnyWidget("notification_root").Show(true);
 #endif
 #endif
 #endif
 
 return layoutRoot;
 }
 
 override bool OnClick(Widget w, int x, int y, int button)
 {
 super.OnClick(w, x, y, button);
 if (w == m_btnLeave)
 {
 Leave();
 return true;
 }
 return false;
 }
 
 void Show()
 {
 if (layoutRoot)
 {
 layoutRoot.Show(true);
 m_HintPanel = new UiHintPanelLoading(layoutRoot.FindAnyWidget("hint_frame0"));
 }
 }
 
 void Hide()
 {
 if (layoutRoot)
 layoutRoot.Show(false);
 m_HintPanel = null;
 }
 
 void SetTime(int time)
 {
 string text = "";
 TimeConversions.ConvertSecondsToFullTime(time, m_FullTime);
 if (!m_IsRespawn)
 text = "#menu_loading_in_";
 else
 text = "#dayz_game_spawning_in_";
 
 if (m_FullTime.m_Days > 0)
 text += "dhms";
 else if (m_FullTime.m_Hours > 0)
 text += "hms";
 else if (m_FullTime.m_Minutes > 0)
 text += "ms";
 else
 text += "s";
 
 text = Widget.TranslateString(text);
 text = string.Format(text, m_FullTime.m_Seconds, m_FullTime.m_Minutes, m_FullTime.m_Hours, m_FullTime.m_Days);
 m_txtLabel.SetText(text);
 
 if (m_IsRespawn && time <= 1)
 GetGame().SetLoginTimerFinished();
 }
 
 void SetStatus(string status)
 {
 m_txtDescription.SetText(status);
 }
 
 void SetRespawn(bool value)
 {
 m_IsRespawn = value;
 }
 
 bool IsRespawn()
 {
 return m_IsRespawn;
 }
 
 override protected bool CanChangeHintPage(float timeAccu)
 {
 return timeAccu >= GameConstants.LOADING_SCREEN_HINT_INTERVAL && m_FullTime.m_Seconds >= GameConstants.LOADING_SCREEN_HINT_INTERVAL_MIN;
 }
};
 
class LoginTimeStatic extends LoginTimeBase
{
 void LoginTimeStatic()
 {
 Init();
 
 m_IsStatic = true;
 }
 
 void ~LoginTimeStatic()
 {
 }
};
 
 
 
class ConnectionLost
{
 private ref Widget m_WidgetRoot;
 private TextWidget m_TextWidgetTitle;
 private float m_duration;
 
 void ConnectionLost(DayZGame game)
 { 
 m_WidgetRoot = game.GetWorkspace().CreateWidgets("gui/layouts/day_z_connection_lost.layout");
 m_WidgetRoot.Show(false);
 
 Class.CastTo(m_TextWidgetTitle, m_WidgetRoot.FindAnyWidget("TextWidget"));
 m_duration = 0.0;
 }
 
 void Show()
 {
 if (!m_WidgetRoot.IsVisible())
 {
 if (g_Game.GetUIManager().IsDialogVisible())
 {
 g_Game.GetUIManager().HideDialog();
 }
 
 m_WidgetRoot.Show(true);
 m_TextWidgetTitle.SetText("");
 }
 }
 
 void Hide()
 {
 if (m_WidgetRoot.IsVisible())
 {
 m_WidgetRoot.Show(false);
 }
 }
 
 void SetText(string text)
 {
 m_TextWidgetTitle.SetText(text);
 }
 
 float GetDuration()
 {
 return m_duration;
 }
 
 void SetDuration(float duration)
 {
 m_duration = duration;
 }
};
 
typedef Param3<string, bool, bool> DayZProfilesOption;
typedef DayZProfilesOption DayZProfilesOptionBool;
typedef Param3<string, int, int> DayZProfilesOptionInt;
typedef Param3<string, float, float> DayZProfilesOptionFloat;
 
class DayZProfilesOptions
{
 private ref map<EDayZProfilesOptions, ref DayZProfilesOptionBool> m_DayZProfilesOptionsBool;
 private ref map<EDayZProfilesOptions, ref DayZProfilesOptionInt> m_DayZProfilesOptionsInt;
 private ref map<EDayZProfilesOptions, ref DayZProfilesOptionFloat> m_DayZProfilesOptionsFloat;
 private DayZGame m_Game
 
 void DayZProfilesOptions()
 {
 m_DayZProfilesOptionsBool = new map<EDayZProfilesOptions, ref DayZProfilesOptionBool>();
 m_DayZProfilesOptionsInt = new map<EDayZProfilesOptions, ref DayZProfilesOptionInt>();
 m_DayZProfilesOptionsFloat = new map<EDayZProfilesOptions, ref DayZProfilesOptionFloat>();
 }
 
 void RegisterProfileOption(EDayZProfilesOptions option, string profileOptionName, bool def = true)
 {
 if (!m_DayZProfilesOptionsBool.Contains(option))
 {
 bool profileVal = GetProfileValueBool(profileOptionName, def);
 
 m_DayZProfilesOptionsBool.Set(option, new DayZProfilesOptionBool(profileOptionName, profileVal, def));
 SetProfileOptionBool(option, profileVal);
 }
 }
 
 void RegisterProfileOptionBool(EDayZProfilesOptions option, string profileOptionName, bool defaultValue = true)
 {
 RegisterProfileOption(option, profileOptionName, defaultValue);
 }
 
 void RegisterProfileOptionInt(EDayZProfilesOptions option, string profileOptionName, int defaultValue = 0)
 {
 if (!m_DayZProfilesOptionsInt.Contains(option))
 {
 string outValue;
 GetGame().GetProfileString(profileOptionName, outValue);
 int value = outValue.ToInt();
 
 m_DayZProfilesOptionsInt.Set(option, new DayZProfilesOptionInt(profileOptionName, value, defaultValue));
 SetProfileOptionInt(option, value);
 }
 }
 
 void RegisterProfileOptionFloat(EDayZProfilesOptions option, string profileOptionName, float defaultValue = 0.0)
 {
 if (!m_DayZProfilesOptionsFloat.Contains(option))
 {
 string outValue;
 GetGame().GetProfileString(profileOptionName, outValue);
 float value = outValue.ToFloat();
 
 m_DayZProfilesOptionsFloat.Set(option, new DayZProfilesOptionFloat(profileOptionName, value, defaultValue));
 SetProfileOptionFloat(option, value);
 }
 }
 
 void ResetOptionsBool()
 {
 if (!m_DayZProfilesOptionsBool)
 {
 m_DayZProfilesOptionsBool = new map<EDayZProfilesOptions, ref DayZProfilesOptionBool>();
 }
 
 foreach (EDayZProfilesOptions e_opt, DayZProfilesOptionBool r_opt : m_DayZProfilesOptionsBool)
 {
 bool profileVal = GetProfileValueBool(r_opt.param1, r_opt.param3);
 SetProfileOptionBool(e_opt, profileVal);
 } 
 }
 
 void ResetOptions()
 {
 ResetOptionsBool();
 }
 
 void ResetOptionsInt()
 {
 if (!m_DayZProfilesOptionsInt)
 {
 m_DayZProfilesOptionsInt = new map<EDayZProfilesOptions, ref DayZProfilesOptionInt>();
 }
 
 foreach (EDayZProfilesOptions e_opt, DayZProfilesOptionInt r_opt : m_DayZProfilesOptionsInt)
 {
 string outValue;
 GetGame().GetProfileString(r_opt.param1, outValue);
 int value = outValue.ToInt();
 SetProfileOptionInt(e_opt, value);
 } 
 }
 
 void ResetOptionsFloat()
 {
 if (!m_DayZProfilesOptionsFloat)
 {
 m_DayZProfilesOptionsFloat = new map<EDayZProfilesOptions, ref DayZProfilesOptionFloat>();
 }
 
 foreach (EDayZProfilesOptions e_opt, DayZProfilesOptionFloat r_opt : m_DayZProfilesOptionsFloat)
 {
 string outValue;
 GetGame().GetProfileString(r_opt.param1, outValue);
 float value = outValue.ToFloat();
 SetProfileOptionFloat(e_opt, value);
 } 
 }
 
 void SetProfileOption(EDayZProfilesOptions option, bool value)
 {
 if (m_DayZProfilesOptionsBool && m_DayZProfilesOptionsBool.Contains(option))
 {
 DayZProfilesOptionBool po = m_DayZProfilesOptionsBool.Get(option);
 
 po.param2 = value;
 GetGame().SetProfileString(po.param1, value.ToString());
 GetGame().SaveProfile();
 } 
 }
 
 void SetProfileOptionBool(EDayZProfilesOptions option, bool value)
 {
 SetProfileOption(option, value);
 }
 
 void SetProfileOptionInt(EDayZProfilesOptions option, int value)
 {
 if (m_DayZProfilesOptionsInt && m_DayZProfilesOptionsInt.Contains(option))
 {
 DayZProfilesOptionInt po = m_DayZProfilesOptionsInt.Get(option);
 
 po.param2 = value;
 GetGame().SetProfileString(po.param1, value.ToString());
 GetGame().SaveProfile();
 } 
 }
 
 void SetProfileOptionFloat(EDayZProfilesOptions option, float value)
 {
 if (m_DayZProfilesOptionsFloat && m_DayZProfilesOptionsFloat.Contains(option))
 {
 DayZProfilesOptionFloat po = m_DayZProfilesOptionsFloat.Get(option);
 
 po.param2 = value;
 GetGame().SetProfileString(po.param1, value.ToString());
 GetGame().SaveProfile();
 } 
 }
 
 bool GetProfileOption(EDayZProfilesOptions option)
 {
 if (m_DayZProfilesOptionsBool && m_DayZProfilesOptionsBool.Contains(option))
 {
 DayZProfilesOptionBool po = m_DayZProfilesOptionsBool.Get(option);
 return po.param2;
 }
 
 return true;
 }
 
 bool GetProfileOptionBool(EDayZProfilesOptions option)
 {
 return GetProfileOption(option);
 }
 
 int GetProfileOptionInt(EDayZProfilesOptions option)
 {
 if (m_DayZProfilesOptionsInt && m_DayZProfilesOptionsInt.Contains(option))
 {
 DayZProfilesOptionInt po = m_DayZProfilesOptionsInt.Get(option);
 return po.param2;
 }
 
 return 0;
 }
 
 float GetProfileOptionFloat(EDayZProfilesOptions option)
 {
 if (m_DayZProfilesOptionsFloat && m_DayZProfilesOptionsFloat.Contains(option))
 {
 DayZProfilesOptionFloat po = m_DayZProfilesOptionsFloat.Get(option);
 return po.param2;
 }
 
 return 0.0;
 }
 
 bool GetProfileOptionDefault(EDayZProfilesOptions option)
 {
 return GetProfileOptionDefaultBool(option);
 }
 
 bool GetProfileOptionDefaultBool(EDayZProfilesOptions option)
 {
 if (m_DayZProfilesOptionsBool && m_DayZProfilesOptionsBool.Contains(option))
 {
 DayZProfilesOptionBool po = m_DayZProfilesOptionsBool.Get(option);
 return po.param3;
 }
 
 ErrorEx("Invalid profile option id! Returning 'true'.", ErrorExSeverity.WARNING);
 return true;
 }
 
 int GetProfileOptionDefaultInt(EDayZProfilesOptions option)
 {
 if (m_DayZProfilesOptionsInt && m_DayZProfilesOptionsInt.Contains(option))
 {
 DayZProfilesOptionInt po = m_DayZProfilesOptionsInt.Get(option);
 return po.param3;
 }
 
 ErrorEx("Invalid profile option id! Returning '0'.", ErrorExSeverity.WARNING);
 return 0;
 }
 
 float GetProfileOptionDefaultFloat(EDayZProfilesOptions option)
 {
 if (m_DayZProfilesOptionsFloat && m_DayZProfilesOptionsFloat.Contains(option))
 {
 DayZProfilesOptionFloat po = m_DayZProfilesOptionsFloat.Get(option);
 return po.param3;
 }
 
 ErrorEx("Invalid profile option id! Returning '0.0'.", ErrorExSeverity.WARNING);
 return 0.0;
 }
 
 map<EDayZProfilesOptions, ref DayZProfilesOptionBool> GetProfileOptionMap()
 {
 if (m_DayZProfilesOptions)
 return m_DayZProfilesOptions;
 
 return null;
 }
 
 private ref map<EDayZProfilesOptions, ref DayZProfilesOption> m_DayZProfilesOptions;
}
 
enum DayZGameState
{
 UNDEFINED,
 MAIN_MENU,
 JOIN,
 PARTY,
 CONNECT,
 CONNECTING,
 IN_GAME
}
 
enum DayZLoadState
{
 UNDEFINED,
 MAIN_MENU_START,
 MAIN_MENU_CONTROLLER_SELECT,
 MAIN_MENU_USER_SELECT,
 JOIN_START,
 JOIN_CONTROLLER_SELECT,
 JOIN_USER_SELECT,
 PARTY_START,
 PARTY_CONTROLLER_SELECT,
 PARTY_USER_SELECT,
 CONNECT_START,
 CONNECT_USER_SELECT,
 CONNECT_CONTROLLER_SELECT,
 MISSION_START,
 MISSION_USER_SELECT,
 MISSION_CONTROLLER_SELECT
}
 
class LoadingScreen
{
 ref Widget m_WidgetRoot;
 TextWidget m_TextWidgetTitle;
 TextWidget m_TextWidgetStatus;
 TextWidget m_ModdedWarning;
 ImageWidget m_ImageWidgetBackground;
 DayZGame m_DayZGame;
 float m_LastProgressUpdate;
 
 ImageWidget m_ImageLogoMid;
 ImageWidget m_ImageLogoCorner;
 ImageWidget m_ImageLoadingIcon;
 ImageWidget m_ImageBackground;
 ProgressBarWidget m_ProgressLoading;
 float m_ImageLoadingIconRotation;
 TextWidget m_ProgressText;
 
 int m_Counter;
 ref Timer m_Timer;
 ref UiHintPanelLoading m_HintPanel;
 void LoadingScreen(DayZGame game)
 {
 m_DayZGame = game;
 
 m_WidgetRoot = game.GetLoadingWorkspace().CreateWidgets("gui/layouts/loading.layout");
 Class.CastTo(m_ImageLogoMid, m_WidgetRoot.FindAnyWidget("ImageLogoMid"));
 Class.CastTo(m_ImageLogoCorner, m_WidgetRoot.FindAnyWidget("ImageLogoCorner"));
 
 Class.CastTo(m_TextWidgetTitle, m_WidgetRoot.FindAnyWidget("TextWidget"));
 Class.CastTo(m_TextWidgetStatus, m_WidgetRoot.FindAnyWidget("StatusText"));
 Class.CastTo(m_ImageWidgetBackground, m_WidgetRoot.FindAnyWidget("ImageBackground"));
 Class.CastTo(m_ImageLoadingIcon, m_WidgetRoot.FindAnyWidget("ImageLoadingIcon"));
 Class.CastTo(m_ModdedWarning, m_WidgetRoot.FindAnyWidget("ModdedWarning"));
 
 m_ImageBackground = ImageWidget.Cast(m_WidgetRoot.FindAnyWidget("ImageBackground"));
 m_ProgressLoading = ProgressBarWidget.Cast(m_WidgetRoot.FindAnyWidget("LoadingBar"));
 
 string tmp;
 m_ProgressText = TextWidget.Cast(m_WidgetRoot.FindAnyWidget("ProgressText"));
 if (GetGame())
 {
 m_ProgressText.Show(GetGame().CommandlineGetParam("loadingTest", tmp));
 }
 m_WidgetRoot.FindAnyWidget("notification_root").Show(false);
 
 #ifdef PLATFORM_CONSOLE
 #ifdef PLATFORM_XBOX
 #ifdef BUILD_EXPERIMENTAL
 Widget expNotification = m_WidgetRoot.FindAnyWidget("notification_root");
 if (expNotification)
 {
 expNotification.Show(true);
 }
 #endif
 #endif
 #endif
 
 m_ModdedWarning.Show(g_Game.ReportModded());
 m_ImageLogoMid.Show(true);
 m_ImageLogoCorner.Show(false);
 
 m_ImageWidgetBackground.Show(true); 
 m_Counter = 0;
 
 // lighten up your desktop
 game.GetBacklit().LoadingAnim();
 
 ProgressAsync.SetProgressData(m_ProgressLoading);
 ProgressAsync.SetUserData(m_ImageBackground);
 }
 
 void OnTimer();
 
 void Inc()
 {
 m_LastProgressUpdate = m_DayZGame.GetTickTime();
 m_Counter++;
 if (m_Counter == 1)
 {
 Show();
 }
 }
 
 void Dec()
 {
 m_Counter = m_Counter - 1;
 
 if (m_Counter <= 0)
 {
 m_Counter = 0;
 EndLoading();
 m_HintPanel = null;
 }
 }
 
 void EndLoading()
 {
 ProgressAsync.SetProgressData(null);
 ProgressAsync.SetUserData(null);
 m_WidgetRoot.Show(false);
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Call(g_Game.CheckDialogs);
 }
 
 bool IsLoading()
 {
 return m_WidgetRoot.IsVisible();
 }
 
 void SetTitle(string title)
 {
 m_TextWidgetTitle.SetText(title);
 }
 
 void SetStatus(string status)
 {
 m_TextWidgetStatus.SetText(status);
 }
 
 void SetProgress(float val)
 {
 float time_delta = m_DayZGame.GetTickTime() - m_LastProgressUpdate;
 
 m_LastProgressUpdate = m_DayZGame.GetTickTime();
 }
 
 void OnUpdate(float timeslice)
 {
 
 }
 
 void ShowEx(DayZGame game)
 {
 if (!m_HintPanel)
 {
 m_HintPanel = new UiHintPanelLoading(m_WidgetRoot.FindAnyWidget("hint_frame"));
 m_HintPanel.Init(game);
 }
 
 Show();
 }
 
 void Show()
 {
 Widget lIcon = m_ImageBackground;
 Widget pText = m_ProgressLoading;
 m_ProgressText.SetText("");
 m_ProgressLoading.SetCurrent(0.0);
 m_ImageBackground.SetMaskProgress(0.0);
 
 if (!m_WidgetRoot.IsVisible())
 {
 if (m_DayZGame.GetUIManager().IsDialogVisible())
 {
 m_DayZGame.GetUIManager().HideDialog();
 }
 
 if (m_DayZGame.GetMissionState() == DayZGame.MISSION_STATE_MAINMENU)
 {
 m_ImageLogoMid.Show(false);
 m_ImageLogoCorner.Show(false); 
 m_ImageWidgetBackground.Show(true); 
 m_TextWidgetStatus.Show(true);
 }
 else
 {
 m_ImageLogoMid.Show(true);
 m_ImageLogoCorner.Show(false);
 m_ImageWidgetBackground.Show(true);
 m_TextWidgetStatus.Show(false);
 }
 
 m_WidgetRoot.Show(true);
 m_TextWidgetTitle.SetText("");
 m_TextWidgetStatus.SetText("");
 }
 
 ProgressAsync.SetProgressData(pText);
 ProgressAsync.SetUserData(lIcon);
 }
 
 void Hide(bool force)
 {
 if (force)
 {
 while (m_Counter > 0)
 {
 Dec();
 }
 }
 
 if (m_Counter <= 0)
 {
 m_WidgetRoot.Show(false);
 ProgressAsync.SetUserData(null);
 ProgressAsync.SetProgressData(null);
 m_HintPanel = null;
 }
 }
};
 
 
class DayZGame extends CGame
{
 protected ref BillboardSetHandler m_BillboardSetHandler;
 
 const int MISSION_STATE_MAINMENU = 0;
 const int MISSION_STATE_GAME = 1;
 const int MISSION_STATE_FINNISH = 2;
 
 private const int STATS_COUNT = EConnectivityStatType.COUNT;
 private EConnectivityStatLevel m_ConnectivityStatsStates[STATS_COUNT];
 
 private int m_MissionState;
 
 //HK stuff
 protected DayZGameState m_GameState;
 protected DayZLoadState m_LoadState;
 protected ref NotificationUI m_Notifications;
 protected bool m_FirstConnect = true;
 //End HK stuff
 
 ref LoadingScreen m_loading;
 private ref LoginTimeBase m_LoginTimeScreen;
 private ref LoginQueueBase m_LoginQueue;
 private int m_LoginTime;
 
 private ref ConnectionLost m_connectionLost;
 private ref TimerQueue m_timerQueue[CALL_CATEGORY_COUNT];
 private ref ScriptCallQueue m_callQueue[CALL_CATEGORY_COUNT];
 private ref ScriptInvoker m_updateQueue[CALL_CATEGORY_COUNT];
 private ref ScriptInvoker m_postUpdateQueue[CALL_CATEGORY_COUNT];
 private ref DragQueue m_dragQueue;
 private ref DayZProfilesOptions m_DayZProfileOptions;
 private bool m_early_access_dialog_accepted;
 private UIScriptedMenu m_keyboard_handler;
 private ScriptModule m_mission_module;
 private string m_MissionPath;
 private string m_MissionFolderPath;
 private bool m_IsCtrlHolding;
 private bool m_IsWinHolding;
 private bool m_IsLeftAltHolding;
 private bool m_IsRightAltHolding;
 
 private bool m_IsWorldWetTempUpdateEnabled = true;
 private bool m_IsFoodDecayEnabled = true;
 private float m_FoodDecayModifier;
 
 static bool m_ReportModded;
 private bool m_IsStressTest;
 private bool m_AimLoggingEnabled;
 int m_OriginalCharactersCount;
 private string m_PlayerName;
 private bool m_IsNewCharacter;
 private bool m_IsConnecting;
 private bool m_ConnectFromJoin;
 private bool m_ShouldShowControllerDisconnect;
 private bool m_CursorDesiredVisibilityScript = true;
 private int m_PreviousGamepad;
 private float m_UserFOV;
 
 private float m_DeltaTime;
 
 float m_volume_sound;
 float m_volume_speechEX;
 float m_volume_music;
 float m_volume_VOIP;
 float m_volume_radio;
 
 float m_PreviousEVValue;
 float m_EVValue = 0;
 
 #ifdef DIAG_DEVELOPER
 private static ref ServerFpsStatsUpdatedEventParams m_ServerFpsStatsParams; 
 #endif
 
 static ref AmmoCamParams m_AmmoShakeParams = new AmmoCamParams();//TODO: make static, reuse
 
 static ref ScriptInvoker Event_OnRPC = new ScriptInvoker();
 
 private ref Backlit m_Backlit;
 
 private ref array<string> m_CharClassNames = new array<string>();
 private ref array<int> m_ConnectedInputDeviceList; //has to be owned here, 'Input' is a native class
 
 //Used for helicrash sound
 private ref EffectSound m_CrashSound;
 
 //Used for Artillery sound
 private ref EffectSound m_ArtySound;
 private const int MIN_ARTY_SOUND_RANGE = 300; // The distance under which sound is no longer heard
 
 static ref NoiseParams m_NoiseParams = new NoiseParams();
 #ifdef DEVELOPER
 static bool m_IsPreviewSpawn;
 #endif
 #ifdef DIAG_DEVELOPER
 ref CameraToolsMenuServer m_CameraToolsMenuServer;
 #endif
 // CGame override functions
 void DayZGame()
 {
 PPEManagerStatic.CreateManagerStatic();
 
#ifdef PLATFORM_CONSOLE
 SetMainMenuWorld("MainMenuSceneXbox");
#endif
 m_MissionState = MISSION_STATE_GAME;
 
 m_keyboard_handler = null;
 
 #ifdef DEVELOPER
 m_early_access_dialog_accepted = true;
 #endif
 
 for (int i = 0; i < CALL_CATEGORY_COUNT; i++)
 {
 m_callQueue[i] = new ScriptCallQueue();
 m_updateQueue[i] = new ScriptInvoker();
 m_timerQueue[i] = new TimerQueue();
 
 m_postUpdateQueue[i] = new ScriptInvoker();
 }
 
 m_dragQueue = new DragQueue;
 
 m_LoginTime = 0;
 
 string tmp;
 if (CommandlineGetParam("stresstest", tmp))
 {
 m_IsStressTest = true;
 }
 
 if (CommandlineGetParam("doAimLogs", tmp))
 {
 m_AimLoggingEnabled = true;
 }
 
 // initialize backlit effects
 m_Backlit = new Backlit();
 m_Backlit.OnInit(this);
 
 m_ReportModded = GetModToBeReported();
 
 #ifndef NO_GUI
 if (m_loading == null)
 {
 m_loading = new LoadingScreen(this);
 }
 
 if (m_loading)
 {
 m_loading.ShowEx(this);
 }
 
 RefreshMouseCursorVisibility();
 #endif
 
 Debug.Init();
 Component.Init();
 CachedObjectsParams.Init();
 CachedObjectsArrays.Init();
 BleedChanceData.InitBleedChanceData();
 GetUApi().PresetSelect(GetUApi().PresetCurrent());
 
 m_DayZProfileOptions = new DayZProfilesOptions();
 
 GetCallQueue(CALL_CATEGORY_GUI).Call(DeferredInit);
 GetCallQueue(CALL_CATEGORY_GAMEPLAY).Call(GlobalsInit);
 
 string path = "cfgVehicles";
 string child_name = "";
 int count = ConfigGetChildrenCount(path);
 
 for (int p = 0; p < count; ++p)
 {
 ConfigGetChildName(path, p, child_name);
 
 if (ConfigGetInt(path + " " + child_name + " scope") == 2 && IsKindOf(child_name, "SurvivorBase"))
 m_CharClassNames.Insert(child_name);
 }
 
 m_IsConnecting = false;
 m_ConnectFromJoin = false;
 }
 
 // ------------------------------------------------------------
 private void ~DayZGame()
 {
 PPEManagerStatic.DestroyManagerStatic();
 BleedChanceData.Cleanup();
 NotificationSystem.CleanupInstance();
 
 g_Game = null;
 SetDispatcher(null);
 Print("~DayZGame()");
 }
 
 // ------------------------------------------------------------
 void DeferredInit()
 {
 GameOptions opt = new GameOptions();
 opt.Initialize();
 
 GetInput().UpdateConnectedInputDeviceList();
 
 m_UserFOV = GetUserFOVFromConfig();
 
 m_volume_sound = GetSoundScene().GetSoundVolume();
 m_volume_speechEX = GetSoundScene().GetSpeechExVolume();
 m_volume_music = GetSoundScene().GetMusicVolume();
 m_volume_VOIP = GetSoundScene().GetVOIPVolume();
 m_volume_radio = GetSoundScene().GetRadioVolume();
 
 PPEManagerStatic.GetPPEManager().Init();
 GetMenuDefaultCharacterData();
 }
 
 // ------------------------------------------------------------
 void GlobalsInit()
 {
 if (GetCEApi())
 {
 m_IsWorldWetTempUpdateEnabled = (GetCEApi().GetCEGlobalInt("WorldWetTempUpdate") == 1);
 
 m_FoodDecayModifier = GetCEApi().GetCEGlobalFloat("FoodDecay");
 
 //check for legacy INT format, if value == float.MIN when read as FLOAT, it is of type INT, so we read it as such below 
 if (m_FoodDecayModifier == float.MIN)
 {
 m_FoodDecayModifier = GetCEApi().GetCEGlobalInt("FoodDecay");
 }
 }
 
 //we need to perform the load here as some objects behaving correctly after spawn is dependent on CE being initialized before spawning them
 ObjectSpawnerHandler.OnGameplayDataHandlerLoad();
 }
 
 // ------------------------------------------------------------
 void RegisterProfilesOptions()
 {
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.CROSSHAIR, SHOW_CROSSHAIR);
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.HUD, SHOW_HUD);
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.QUICKBAR, SHOW_QUICKBAR);
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.SERVER_MESSAGES, SYSTEM_CHAT_MSG);
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.USERS_CHAT, DIRECT_CHAT_MSG);
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.RADIO_CHAT, RADIO_CHAT_MSG);
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.GAME_MESSAGES, GAME_CHAT_MSG, false);
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.ADMIN_MESSAGES, ADMIN_CHAT_MSG, false);
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.PLAYER_MESSAGES, PLAYER_CHAT_MSG, false);
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.SERVERINFO_DISPLAY, SHOW_SERVERINFO, true);
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.BLEEDINGINDICATION, ENABLE_BLEEDINGINDICATION, true);
 m_DayZProfileOptions.RegisterProfileOptionBool(EDayZProfilesOptions.CONNECTIVITY_INFO, SHOW_CONNECTIVITYINFO, true);
 
 m_DayZProfileOptions.RegisterProfileOptionFloat(EDayZProfilesOptions.HUD_BRIGHTNESS, HUD_BRIGHTNESS, 0.0);
 }
 
 void ResetProfileOptions()
 {
 m_DayZProfileOptions.ResetOptionsBool();
 m_DayZProfileOptions.ResetOptionsInt();
 m_DayZProfileOptions.ResetOptionsFloat();
 }
 
 void SetMissionPath(string path)
 {
 m_MissionPath = path;
 
 int pos_end = 0;
 int pos_cur = 0;
 
 while (pos_cur != -1)
 {
 pos_end = pos_cur;
 pos_cur = path.IndexOfFrom(pos_cur + 1 , "\\");
 }
 
 m_MissionFolderPath = path.Substring(0, pos_end); 
 }
 
 string GetMissionPath()
 {
 return m_MissionPath;
 }
 
 string GetMissionFolderPath()
 {
 return m_MissionFolderPath;
 }
 
 override ScriptCallQueue GetCallQueue(int call_category)
 {
 return m_callQueue[call_category];
 }
 
 override ScriptInvoker GetUpdateQueue(int call_category)
 {
 return m_updateQueue[call_category];
 }
 
 override ScriptInvoker GetPostUpdateQueue(int call_category)
 {
 return m_postUpdateQueue[call_category];
 }
 
 override TimerQueue GetTimerQueue(int call_category)
 {
 return m_timerQueue[call_category];
 }
 
 override DragQueue GetDragQueue()
 {
 return m_dragQueue;
 }
 
 // ------------------------------------------------------------
 void OnGameplayDataHandlerLoad()
 {
 
 }
 
 
 // ------------------------------------------------------------
 int GetMissionState()
 {
 return m_MissionState;
 }
 
 // ------------------------------------------------------------
 void SetMissionState(int state)
 {
 m_MissionState = state;
 }
 
 // ------------------------------------------------------------
 bool GetProfileOption(EDayZProfilesOptions option)
 {
 return m_DayZProfileOptions.GetProfileOption(option);
 }
 
 bool GetProfileOptionBool(EDayZProfilesOptions option)
 {
 return GetProfileOption(option);
 }
 
 int GetProfileOptionInt(EDayZProfilesOptions option)
 {
 return m_DayZProfileOptions.GetProfileOptionInt(option);
 }
 
 float GetProfileOptionFloat(EDayZProfilesOptions option)
 {
 return m_DayZProfileOptions.GetProfileOptionFloat(option);
 }
 
 bool GetProfileOptionDefault(EDayZProfilesOptions option)
 {
 return m_DayZProfileOptions.GetProfileOptionDefaultBool(option);
 }
 
 bool GetProfileOptionDefaultBool(EDayZProfilesOptions option)
 {
 return GetProfileOptionDefault(option);
 }
 
 int GetProfileOptionDefaultInt(EDayZProfilesOptions option)
 {
 return m_DayZProfileOptions.GetProfileOptionDefaultInt(option);
 }
 
 float GetProfileOptionDefaultFloat(EDayZProfilesOptions option)
 {
 return m_DayZProfileOptions.GetProfileOptionDefaultFloat(option);
 }
 
 void SetProfileOption(EDayZProfilesOptions option, bool value)
 {
 m_DayZProfileOptions.SetProfileOptionBool(option, value);
 }
 
 void SetProfileOptionBool(EDayZProfilesOptions option, bool value)
 {
 SetProfileOption(option, value);
 }
 
 void SetProfileOptionInt(EDayZProfilesOptions option, int value)
 {
 m_DayZProfileOptions.SetProfileOptionInt(option, value);
 }
 
 void SetProfileOptionFloat(EDayZProfilesOptions option, float value)
 {
 m_DayZProfileOptions.SetProfileOptionFloat(option, value);
 }
 
 map<EDayZProfilesOptions, ref DayZProfilesOption> GetProfileOptionMap()
 {
 return m_DayZProfileOptions.GetProfileOptionMap();
 }
 
 bool IsStressTest()
 {
 return m_IsStressTest;
 }
 
 bool IsAimLogEnabled()
 {
 return m_AimLoggingEnabled;
 }
 
 void SetGameState(DayZGameState state)
 {
 m_GameState = state;
 }
 
 DayZGameState GetGameState()
 {
 return m_GameState;
 }
 
 void SetLoadState(DayZLoadState state)
 {
 m_LoadState = state;
 }
 
 DayZLoadState GetLoadState()
 {
 return m_LoadState;
 }
 
 static bool ReportModded()
 {
 return m_ReportModded;
 }
 
 Backlit GetBacklit()
 {
 return m_Backlit;
 }
 
 // ------------------------------------------------------------
 override bool IsInventoryOpen()
 {
#ifndef NO_GUI
 if (GetUIManager().FindMenu(MENU_INVENTORY) != NULL)
 {
 return true;
 }
#endif
 return false;
 }
 
 // ------------------------------------------------------------
 void EarlyAccessDialog(UIScriptedMenu parent)
 {
 if (!m_early_access_dialog_accepted)
 {
 g_Game.GetUIManager().EnterScriptedMenu(MENU_EARLYACCESS, parent);
 m_early_access_dialog_accepted = true;
 }
 }
 
 // ------------------------------------------------------------
 override UIScriptedMenu CreateScriptedMenu(int id)
 {
 #ifndef NO_GUI
 Mission mission = GetMission();
 if (mission)
 {
 return mission.CreateScriptedMenu(id);
 }
 #endif
 return NULL;
 }
 
 // ------------------------------------------------------------
 void ReloadMission()
 {
 #ifdef DEVELOPER
 Print("Reloading mission module!");
 CreateMission(m_MissionPath);
 #endif
 }
 
 // ------------------------------------------------------------
 void CancelLoginQueue()
 {
 if (m_LoginQueue)
 {
 if (m_LoginQueue.IsStatic())
 {
 m_LoginQueue.Hide();
 delete m_LoginQueue;
 }
 else
 {
 m_LoginQueue.Close();
 }
 }
 }
 // ------------------------------------------------------------
 void CancelLoginTimeCountdown()
 {
 GetCallQueue(CALL_CATEGORY_SYSTEM).Remove(this.LoginTimeCountdown);
 
 if (m_LoginTimeScreen)
 {
 if (m_LoginTimeScreen.IsStatic())
 {
 m_LoginTimeScreen.Hide();
 delete m_LoginTimeScreen;
 }
 else
 {
 m_LoginTimeScreen.Close();
 }
 }
 }
 // ------------------------------------------------------------
 private void ClearConnectivityStates()
 {
 for (int i = 0; i < STATS_COUNT; i++)
 m_ConnectivityStatsStates[i] = 0;
 }
 
 
 // ------------------------------------------------------------
 override void OnEvent(EventType eventTypeId, Param params)
 {
 string address;
 int port;
 int high, low;
 
 switch (eventTypeId)
 {
 case StartupEventTypeID:
 {
 #ifndef SERVER
 // Just call it, to create the global instance if it doesn't exist yet
 ParticleManager.GetInstance();
 #endif
 break;
 }
 case MPSessionStartEventTypeID:
 {
 #ifndef SERVER
 ClearConnectivityStates();
 #endif
 m_FirstConnect = true;
 ClientData.ResetClientData();
 break;
 }
 case MPSessionEndEventTypeID:
 {
 LoadingHide();
 CancelLoginTimeCountdown();
 SetConnecting(false);
 SetGameState(DayZGameState.MAIN_MENU);
 m_FirstConnect = true;
 #ifdef PLATFORM_CONSOLE
 if (GetUserManager().GetSelectedUser())
 {
 OnlineServices.LeaveGameplaySession();
 OnlineServices.ClearCurrentServerInfo();
 if (GetGameState() == DayZGameState.IN_GAME)
 {
 SetLoadState(DayZLoadState.MAIN_MENU_START);
 }
 }
 m_Notifications.ClearVoiceNotifications();
 #endif
 
 // analytics - disconnected player
 StatsEventDisconnectedData discData = new StatsEventDisconnectedData();
 discData.m_CharacterId = g_Game.GetDatabaseID();
 discData.m_Reason = "quit";
 Analytics.PlayerDisconnected(discData);
 break;
 }
 case MPSessionFailEventTypeID:
 {
 CancelLoginQueue();
 LoadingHide(true);
 SetConnecting(false);
 ProgressAsync.DestroyAllPendingProgresses();
 
 if (GetGameState() == DayZGameState.CONNECTING)
 {
 SetGameState(DayZGameState.MAIN_MENU);
 }
 
 break;
 }
 case MPSessionPlayerReadyEventTypeID:
 {
 LoadingHide(true);
 ProgressAsync.DestroyAllPendingProgresses();
 
 SetGameState(DayZGameState.IN_GAME);
 
 // analytics - spawned
 StatsEventSpawnedData spawnData = new StatsEventSpawnedData();
 spawnData.m_CharacterId = g_Game.GetDatabaseID();
 spawnData.m_Lifetime = 0;
 spawnData.m_Position = vector.Zero;
 if (GetPlayer())
 {
 spawnData.m_Position = GetPlayer().GetPosition();
 }
 spawnData.m_DaytimeHour = 0;
 spawnData.m_Population = 0;
 Analytics.PlayerSpawned(spawnData);
 
 #ifdef PLATFORM_CONSOLE
 m_Notifications.ClearVoiceNotifications();
 OnlineServices.SetMultiplayState(true);
 #endif
 if (m_FirstConnect)
 {
 m_FirstConnect = false;
 if (GetHostAddress(address, port))
 {
 AddVisitedServer(address, port);
 }
 
 #ifdef PLATFORM_CONSOLE
 #ifndef PLATFORM_WINDOWS // if app is not on Windows with -XBOX parameter
 if (null != GetUserManager().GetSelectedUser())
 {
 OnlineServices.EnterGameplaySession();
 OnlineServices.LoadVoicePrivilege();
 }
 #endif
 #endif
 }
 
 UpdateInputDeviceDisconnectWarning();
 
 break;
 }
 case MPConnectionLostEventTypeID:
 {
 MPConnectionLostEventParams conLost_params;
 if (Class.CastTo(conLost_params, params))
 {
 int duration = conLost_params.param1;
 OnMPConnectionLostEvent(duration);
 }
 break;
 }
 case WorldCleaupEventTypeID:
 {
 LoadingShow();
 break;
 }
 case DialogQueuedEventTypeID:
 {
 GetCallQueue(CALL_CATEGORY_SYSTEM).Call(g_Game.CheckDialogs);
 break;
 }
 case ChatMessageEventTypeID:
 {
 ChatMessageEventParams chat_params;
 if (Class.CastTo(chat_params, params))
 {
 
 }
 break;
 }
 case ProgressEventTypeID:
 {
 ProgressEventParams prog_params;
 if (Class.CastTo(prog_params, params))
 LoadProgressUpdate(prog_params.param1, prog_params.param2, prog_params.param3);
 break;
 }
 case LoginTimeEventTypeID:
 {
 LoginTimeEventParams loginTimeParams;
 if (Class.CastTo(loginTimeParams, params))
 {
 OnLoginTimeEvent(loginTimeParams.param1);
 }
 break;
 } 
 case RespawnEventTypeID:
 {
 RespawnEventParams respawnParams;
 if (Class.CastTo(respawnParams, params))
 {
 OnRespawnEvent(respawnParams.param1);
 } 
 break;
 }
 case PreloadEventTypeID:
 {
 PreloadEventParams preloadParams;
 if (Class.CastTo(preloadParams, params))
 {
 OnPreloadEvent(preloadParams.param1);
 } 
 break;
 }
 case LogoutEventTypeID:
 {
 LogoutEventParams logoutParams;
 if (Class.CastTo(logoutParams, params))
 {
 GetCallQueue(CALL_CATEGORY_GUI).Call(GetMission().StartLogoutMenu, logoutParams.param1); 
 }
 break;
 }
 case SelectedUserChangedEventTypeID:
 {
 OnlineServices.Init();
 break;
 }
 case LoginStatusEventTypeID:
 {
 LoginStatusEventParams loginStatusParams;
 Class.CastTo(loginStatusParams, params);
 
 string msg1 = loginStatusParams.param1;
 string msg2 = loginStatusParams.param2;
 string finalMsg;
 
 // write either to login time screen or loading screen
 if (m_LoginTimeScreen)
 {
 finalMsg = msg1;
 // login time screen supports two lines
 if (msg2.Length() > 0)
 finalMsg += "\n" + msg2;
 
 m_LoginTimeScreen.SetStatus(finalMsg);
 }
 else if (m_loading)
 {
 // loading only one line, but it's a long one
 finalMsg = msg1 + " " + msg2;
 m_loading.SetStatus(finalMsg);
 }
 break;
 }
 case ConnectingStartEventTypeID:
 {
 g_Game.SetGameState(DayZGameState.CONNECTING);
 SetConnecting(true);
 break;
 }
 case ConnectingAbortEventTypeID:
 {
 g_Game.SetGameState(DayZGameState.MAIN_MENU);
 SetConnecting(false);
 if (m_ConnectFromJoin)
 {
 m_ConnectFromJoin = false;
 AbortMission();
 }
 break;
 }
 case DLCOwnerShipFailedEventTypeID:
 {
 DLCOwnerShipFailedParams dlcParams;
 if (Class.CastTo(dlcParams, params))
 {
 Print("### DLC Ownership failed !!! Map: " + dlcParams.param1);
 }
 break;
 }
 case ConnectivityStatsUpdatedEventTypeID:
 {
 ConnectivityStatsUpdatedEventParams connectivityStatsParams; 
 if (Class.CastTo(connectivityStatsParams, params))
 {
 PlayerIdentity playerIdentity = connectivityStatsParams.param1;
 
 int pingAvg = playerIdentity.GetPingAvg();
 if (pingAvg < GetWorld().GetPingWarningThreshold())
 {
 SetConnectivityStatState(EConnectivityStatType.PING, EConnectivityStatLevel.OFF);
 }
 else if (pingAvg < GetWorld().GetPingCriticalThreshold())
 {
 SetConnectivityStatState(EConnectivityStatType.PING, EConnectivityStatLevel.LEVEL1);
 }
 else
 {
 SetConnectivityStatState(EConnectivityStatType.PING, EConnectivityStatLevel.LEVEL2);
 }
 }
 break;
 }
 case ServerFpsStatsUpdatedEventTypeID:
 {
 ServerFpsStatsUpdatedEventParams serverFpsStatsParams; 
 if (Class.CastTo(serverFpsStatsParams, params))
 {
 #ifdef DIAG_DEVELOPER
 m_ServerFpsStatsParams = serverFpsStatsParams;
 #endif
 float fps = serverFpsStatsParams.param1;
 if (fps > GetWorld().GetServerFpsWarningThreshold())
 {
 SetConnectivityStatState(EConnectivityStatType.SERVER_PERF, EConnectivityStatLevel.OFF);
 }
 else if (fps > GetWorld().GetServerFpsCriticalThreshold())
 {
 SetConnectivityStatState(EConnectivityStatType.SERVER_PERF, EConnectivityStatLevel.LEVEL1);
 }
 else
 {
 SetConnectivityStatState(EConnectivityStatType.SERVER_PERF, EConnectivityStatLevel.LEVEL2);
 }
 }
 break;
 }
 }
 
 VONManager.GetInstance().OnEvent(eventTypeId, params);
 
 Mission mission = GetMission();
 if (mission)
 {
 mission.OnEvent(eventTypeId, params);
 }
 
 ErrorModuleHandler emh = ErrorModuleHandler.GetInstance();
 if (emh)
 emh.OnEvent(eventTypeId, params);
 }
 
 protected void SetConnectivityStatState(EConnectivityStatType type, EConnectivityStatLevel level)
 {
 if (level != m_ConnectivityStatsStates[type])
 {
 if (OnConnectivityStatChange(type, level, m_ConnectivityStatsStates[type]))//before setting the prev. level to be the current level, we need to make sure we successfully set the icon
 {
 m_ConnectivityStatsStates[type] = level;
 }
 }
 }
 
 protected bool OnConnectivityStatChange(EConnectivityStatType type, EConnectivityStatLevel newLevel, EConnectivityStatLevel oldLevel)
 {
 if (!GetGame() || !GetGame().GetMission())
 return false;
 Hud hud = GetGame().GetMission().GetHud();
 if (!hud) 
 return false;
 
 hud.SetConnectivityStatIcon(type, newLevel);
 return true;
 }
 
 #ifdef DIAG_DEVELOPER
 private void DrawPerformaceStats(float pingAct, float pingAvg)
 {
 DbgUI.Begin("Performance Stats", 10, 520);
 DbgUI.Text("pingAct:" + pingAct );
 int color = COLOR_WHITE;
 if ( pingAvg >= GetWorld().GetPingCriticalThreshold())
 color = COLOR_RED;
 else if ( pingAvg >= GetWorld().GetPingWarningThreshold())
 color = COLOR_YELLOW;
 
 DbgUI.ColoredText(color, "pingAvg:" + pingAvg);
 DbgUI.Text("Ping Warning Threshold:" + GetWorld().GetPingWarningThreshold());
 DbgUI.Text("Ping Critical Threshold:" + GetWorld().GetPingCriticalThreshold());
 DbgUI.PlotLive("pingAvg history:", 300,150, pingAvg, 2000, 100 );
 DbgUI.Text("Server Fps Warning Threshold:" + GetWorld().GetServerFpsWarningThreshold());
 DbgUI.Text("Server Fps Critical Threshold:" + GetWorld().GetServerFpsCriticalThreshold());
 if (m_ServerFpsStatsParams)// SERVER FPS
 {
 color = COLOR_WHITE;
 if ( m_ServerFpsStatsParams.param1 <= GetWorld().GetServerFpsCriticalThreshold())
 color = COLOR_RED;
 else if ( m_ServerFpsStatsParams.param1 <= GetWorld().GetServerFpsWarningThreshold())
 color = COLOR_YELLOW;
 DbgUI.ColoredText(color, "serverFPS:" + m_ServerFpsStatsParams.param1.ToString() );
 DbgUI.PlotLive("serverFPS history:", 300,150, m_ServerFpsStatsParams.param1, 6000, 100 );
 }
 DbgUI.End();
 }
 #endif
 
 void AddVoiceNotification(VONStopSpeakingEventParams vonStartParams)
 {
 m_Notifications.AddVoiceNotification(vonStartParams.param2, vonStartParams.param1);
 }
 
 void RemoveVoiceNotification(VONStopSpeakingEventParams vonStopParams)
 {
 m_Notifications.RemoveVoiceNotification(vonStopParams.param2);
 }
 
 // ------------------------------------------------------------ 
 void UpdateLoginQueue(float timeslice)
 {
 int pos = GetUIManager().GetLoginQueuePosition();
 
 if (!m_LoginQueue && pos > 0)
 { 
 GetUIManager().CloseAll();
 
 if (GetMission())
 {
 UIScriptedMenu parent = GetUIManager().GetMenu();
 EnterLoginQueue(parent);
 }
 else
 {
 m_LoginQueue = new LoginQueueStatic();
 GetUIManager().ShowScriptedMenu(m_LoginQueue, null);
 }
 }
 if (m_LoginQueue)
 {
 m_LoginQueue.SetPosition(pos);
 
 LoginQueueStatic loginQueue;
 if (LoginQueueBase.CastTo(loginQueue, m_LoginQueue))
 {
 loginQueue.Update(timeslice);
 }
 }
 }
 
 // ------------------------------------------------------------
 void OnLoginTimeEvent(int loginTime)
 {
#ifndef NO_GUI
 // remove login queue if exits 
 CancelLoginQueue(); 
 
 GetUserManager().GetUserDatabaseIdAsync();
 
 m_LoginTime = loginTime;
 
 // timer for login
 if (m_LoginTime > 0)
 { 
 if (!m_LoginTimeScreen)
 {
 GetUIManager().CloseAll();
 
 if (GetMission())
 {
 UIScriptedMenu parent = GetUIManager().GetMenu();
 EnterLoginTime(parent);
 }
 else
 {
 m_LoginTimeScreen = new LoginTimeStatic();
 GetUIManager().ShowScriptedMenu(m_LoginTimeScreen, null);
 }
 }
 
 m_LoginTimeScreen.SetTime(m_LoginTime);
 m_LoginTimeScreen.Show();
 
 GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(this.LoginTimeCountdown, 1000, true);
 }
#endif
 }
 
 // ------------------------------------------------------------
 void LoginTimeCountdown()
 {
 if (m_LoginTime > 0)
 {
 if (m_LoginTimeScreen)
 m_LoginTimeScreen.SetTime(m_LoginTime);
 
 m_LoginTime--;
 }
 else
 {
 // stop the call loop
 CancelLoginTimeCountdown();
 }
 }
 
 // ------------------------------------------------------------
 void OnRespawnEvent(int time)
 { 
 // use login time screen for respawn timer
 if (time >= 0)
 { 
 m_LoginTime = time;
 if (!m_LoginTimeScreen)
 {
 GetUIManager().CloseAll();
 
 UIScriptedMenu parent = GetUIManager().GetMenu();
 EnterLoginTime(parent);
 }
 
 m_LoginTimeScreen.SetRespawn(true);
 m_LoginTimeScreen.SetTime(m_LoginTime);
 m_LoginTimeScreen.Show();
 
 GetCallQueue(CALL_CATEGORY_SYSTEM).CallLater(this.LoginTimeCountdown, 1000, true);
 }
 
 if (GetPlayer())
 GetPlayer().StopDeathDarkeningEffect();
 
 PPERequesterBank.GetRequester(PPERequester_DeathDarkening).Start(new Param1<float>(1.0));
 }
 
 // ------------------------------------------------------------
 void OnPreloadEvent(vector pos)
 {
 // cancel only login time (respawn time is parallel with preload, but login time is not)
 if (m_LoginTimeScreen && !m_LoginTimeScreen.IsRespawn())
 CancelLoginTimeCountdown();
 
 // tell game to continue
 StoreLoginDataPrepare();
 }
 
 // ------------------------------------------------------------
 // Serialize and send default character information to server (must be called)
 void StoreLoginDataPrepare()
 {
 ScriptReadWriteContext ctx = new ScriptReadWriteContext;
 
 //GetMenuData().RequestGetDefaultCharacterData();
 GetMenuDefaultCharacterData().SerializeCharacterData(ctx.GetWriteContext());
 StoreLoginData(ctx.GetWriteContext());
 }
 
 // ------------------------------------------------------------
 void EnterLoginQueue(UIMenuPanel parent)
 {
 m_LoginQueue = LoginQueueBase.Cast(GetUIManager().EnterScriptedMenu(MENU_LOGIN_QUEUE, parent)); 
 }
 
 // ------------------------------------------------------------
 void EnterLoginTime(UIMenuPanel parent)
 { 
 m_LoginTimeScreen = LoginTimeBase.Cast(GetUIManager().EnterScriptedMenu(MENU_LOGIN_TIME, parent)); 
 }
 
 // ------------------------------------------------------------
 void OnMPConnectionLostEvent(int duration)
 {
 if (duration >= 0)//(-1 means conn. reestablished)
 SetConnectivityStatState(EConnectivityStatType.CONN_LOST, EConnectivityStatLevel.LEVEL1);
 else
 SetConnectivityStatState(EConnectivityStatType.CONN_LOST, EConnectivityStatLevel.OFF);
 
 #ifdef PLATFORM_PS4
 //PSN Set multiplay state 
 if (duration < 0 && GetGameState() == DayZGameState.IN_GAME)
 {
 OnlineServices.SetMultiplayState(true);
 }
 else
 {
 OnlineServices.SetMultiplayState(false);
 }
 #endif
 }
 
 // ------------------------------------------------------------
 void LoadProgressUpdate(int progressState, float progress, string title)
 {
 #ifndef NO_GUI
 switch (progressState)
 {
 case PROGRESS_START:
 {
 #ifndef NO_GUI 
 // get out of the black screen immediately
 GetUIManager().ScreenFadeOut(0);
 #endif
 m_loading.Inc();
 m_loading.SetTitle(title);
 if (m_loading.m_HintPanel)
 m_loading.m_HintPanel.ShowRandomPage();
 
 }
 break;
 
 case PROGRESS_FINISH:
 {
 m_loading.Dec();
 }
 break;
 
 case PROGRESS_PROGRESS:
 {
 m_loading.SetProgress(progress);
 
 }
 break;
 
 case PROGRESS_UPDATE:
 {
 m_loading.SetProgress(0);
 }
 break;
 }
 #endif
 }
 
 // ------------------------------------------------------------
 override void OnAfterCreate()
 {
 Math.Randomize(-1);
 }
 
 // ------------------------------------------------------------
 override void OnActivateMessage()
 {
 RefreshMouseCursorVisibility();
 }
 
 // ------------------------------------------------------------
 override void OnDeactivateMessage()
 {
 RefreshMouseCursorVisibility();
 }
 
 // ------------------------------------------------------------
 override bool OnInitialize()
 {
 ParticleList.PreloadParticles();
 
 RegisterProfilesOptions();
 SetHudBrightness(GetHUDBrightnessSetting());
 
 InitNotifications();
 m_Visited = new TStringArray;
 GetProfileStringList("SB_Visited", m_Visited);
 
 if (GetLoadState() == DayZLoadState.UNDEFINED)
 {
 string param;
 
 if (GetCLIParam("join", param))
 {
 JoinLaunch();
 #ifndef PLATFORM_PS4
 CreateTitleScreen();
 #endif
 }
 else if (GetCLIParam("connect", param))
 {
 ConnectLaunch();
 }
 else if (GetCLIParam("mission", param))
 {
 MissionLaunch();
 }
 else if (GetCLIParam("party", param))
 {
 PartyLaunch();
 }
 else
 {
 MainMenuLaunch();
 }
 
 return true;
 }
 
 return false;
 }
 
 void InitNotifications()
 {
 NotificationSystem.InitInstance();
 m_Notifications = new NotificationUI();
 }
 
 protected ref Widget m_IntroMenu;
 protected ref Widget m_GamepadDisconnectMenu; //DEPRECATED
 protected int m_PrevBlur;
 
 protected string m_DatabaseID;
 
 protected string m_ConnectAddress;
 protected int m_ConnectPort;
 protected string m_ConnectPassword;
 
 protected const int MAX_VISITED = 50;
 protected ref TStringArray m_Visited;
 
 string GetDatabaseID()
 {
 return m_DatabaseID;
 }
 
 void SetDatabaseID(string id)
 {
 m_DatabaseID = id;
 if (GetUIManager().GetMenu())
 {
 GetUIManager().GetMenu().Refresh();
 }
 }
 
 void CreateTitleScreen()
 {
 DeleteTitleScreen();
 m_IntroMenu = GetWorkspace().CreateWidgets("gui/layouts/xbox/day_z_title_screen.layout");
 RichTextWidget text_widget = RichTextWidget.Cast(m_IntroMenu.FindAnyWidget("InputPromptText"));
 m_IntroMenu.FindAnyWidget("notification_root").Show(false);
 if (text_widget)
 {
 string text = Widget.TranslateString("#console_start_game");
 #ifdef PLATFORM_XBOX
 BiosUserManager user_manager = GetGame().GetUserManager();
 if (user_manager && user_manager.GetSelectedUser())
 text_widget.SetText(string.Format(text, "<image set=\"xbox_buttons\" name=\"A\" />"));
 else
 text_widget.SetText(string.Format(text, "<image set=\"xbox_buttons\" name=\"A\" />"));
 #endif
 
 #ifdef PLATFORM_PS4
 string confirm = "cross";
 if (GetGame().GetInput().GetEnterButton() == GamepadButton.A)
 {
 confirm = "cross";
 }
 else
 {
 confirm = "circle";
 }
 text_widget.SetText(string.Format(text, "<image set=\"playstation_buttons\" name=\"" + confirm + "\" />"));
 #endif
 }
 
 #ifdef PLATFORM_CONSOLE
 #ifdef PLATFORM_XBOX
 #ifdef BUILD_EXPERIMENTAL
 m_IntroMenu.FindAnyWidget("notification_root").Show(true);
 #endif
 #endif
 #endif
 }
 
 void DeleteTitleScreen()
 {
 if (m_IntroMenu)
 {
 delete m_IntroMenu;
 }
 }
 
 bool ShouldShowControllerDisconnect()
 {
 return m_ShouldShowControllerDisconnect;
 }
 
 void UpdateInputDeviceDisconnectWarning()
 {
 #ifdef PLATFORM_CONSOLE
 if (!GetUIManager().IsMenuOpen(MENU_WARNING_INPUTDEVICE_DISCONNECT))
 {
 m_ShouldShowControllerDisconnect = !GetInput().AreAllAllowedInputDevicesActive();
 if (m_ShouldShowControllerDisconnect)
 {
 GetCallQueue(CALL_CATEGORY_GUI).Call(GetUIManager().EnterScriptedMenu,MENU_WARNING_INPUTDEVICE_DISCONNECT,GetUIManager().GetMenu());
 }
 }
 #endif
 }
 
 void JoinLaunch()
 {
 SetGameState(DayZGameState.JOIN);
 SetLoadState(DayZLoadState.JOIN_START);
 
 #ifdef PLATFORM_CONSOLE
 string join_param;
 if (GetCLIParam("join", join_param))
 {
 BiosUserManager user_manager = GetUserManager();
 user_manager.ParseJoinAsync(join_param);
 }
 #endif
 }
 
 void ConnectLaunch()
 {
 BiosUserManager user_manager = GetUserManager();
 if (user_manager.GetTitleInitiator())
 {
 user_manager.SelectUserEx(user_manager.GetTitleInitiator());
 }
 
 SetGameState(DayZGameState.CONNECT);
 SetLoadState(DayZLoadState.CONNECT_START);
 
 #ifndef PLATFORM_WINDOWS
 #ifdef PLATFORM_CONSOLE
 CreateTitleScreen();
 GamepadCheck();
 #endif
 #else
 ConnectFromCLI();
 #endif
 }
 
 void PartyLaunch()
 {
 SetGameState(DayZGameState.PARTY);
 SetLoadState(DayZLoadState.PARTY_START);
 BiosUserManager user_manager = GetGame().GetUserManager();
 
 string param;
 if (GetCLIParam("party", param))
 {
 user_manager.ParsePartyAsync(param);
 StartRandomCutscene(GetMainMenuWorld());
 }
 }
 
 void MainMenuLaunch()
 {
#ifdef PLATFORM_WINDOWS
 BiosUserManager user_manager = GetUserManager();
 if (user_manager)
 {
 if (user_manager.GetTitleInitiator())
 {
 user_manager.SelectUserEx(user_manager.GetTitleInitiator());
 }
 }
#endif
 
 SetGameState(DayZGameState.MAIN_MENU);
 SetLoadState(DayZLoadState.MAIN_MENU_START); 
 StartRandomCutscene(GetMainMenuWorld()); 
 DeleteTitleScreen();
 }
 
 void MissionLaunch()
 {
 BiosUserManager user_manager = GetUserManager();
 if (user_manager)
 {
 if (user_manager.GetTitleInitiator())
 {
 user_manager.SelectUserEx(user_manager.GetTitleInitiator());
 }
 }
 
 SetGameState(DayZGameState.IN_GAME);
 SetLoadState(DayZLoadState.MISSION_START);
 
 
 #ifndef PLATFORM_WINDOWS
 #ifdef PLATFORM_CONSOLE 
 #ifndef DEVELOPER
 CreateTitleScreen();
 GamepadCheck();
 return;
 #endif
 #endif
 #endif
 
 string mission;
 GetCLIParam("mission", mission);
 PlayMission(mission);
 }
 
 void SelectUser(int gamepad = -1)
 {
 BiosUserManager user_manager = GetUserManager();
 if (user_manager)
 {
 BiosUser selected_user;
 if (gamepad > -1)
 {
 GetInput().GetGamepadUser(gamepad, selected_user);
 #ifdef PLATFORM_PS4
 if (selected_user)
 #endif
 {
 if (user_manager.SelectUserEx(selected_user))
 {
 GetGame().GetInput().IdentifyGamepad(GamepadButton.BUTTON_NONE);
 GetInput().SelectActiveGamepad(gamepad);
 }
 else
 {
 selected_user = user_manager.GetSelectedUser();
 }
 
 #ifdef PLATFORM_PS4
 if (!selected_user.IsOnline())
 {
 user_manager.LogOnUserAsync(selected_user); 
 return;
 }
 #endif
 }
 #ifdef PLATFORM_PS4
 else
 {
 GetInput().ResetActiveGamepad();
 GamepadCheck();
 }
 #endif
 }
 
 if (!selected_user)
 selected_user = user_manager.GetSelectedUser();
 
 if (!selected_user)
 {
 user_manager.PickUserAsync();
 return;
 }
 
 user_manager.SelectUserEx(selected_user);
 
 switch (GetLoadState())
 {
 case DayZLoadState.JOIN_START:
 {
 SetLoadState(DayZLoadState.JOIN_USER_SELECT); 
 break;
 }
 case DayZLoadState.PARTY_START:
 {
 SetLoadState(DayZLoadState.PARTY_USER_SELECT);
 break;
 }
 case DayZLoadState.MAIN_MENU_START:
 {
 SetLoadState(DayZLoadState.MAIN_MENU_USER_SELECT);
 break;
 }
 case DayZLoadState.CONNECT_START:
 {
 SetLoadState(DayZLoadState.CONNECT_USER_SELECT);
 break;
 }
 case DayZLoadState.MISSION_START:
 {
 SetLoadState(DayZLoadState.MISSION_USER_SELECT);
 break;
 }
 default:
 break;
 }
 
 SelectGamepad();
 g_Game.SetHudBrightness(g_Game.GetHUDBrightnessSetting());
 }
 }
 
 void SetPreviousGamepad(int gamepad)
 {
 m_PreviousGamepad = gamepad;
 }
 
 int GetPreviousGamepad()
 {
 return m_PreviousGamepad;
 }
 
 void GamepadCheck()
 {
#ifndef AUTOTEST
 if (GetInput().IsActiveGamepadSelected())
 {
#endif
 DeleteTitleScreen();
 SelectUser();
#ifndef AUTOTEST
 }
 else
 {
 #ifdef PLATFORM_CONSOLE
 #ifndef PLATFORM_WINDOWS
 #ifdef PLATFORM_PS4
 if (GetUserManager().GetSelectedUser())
 {
 int gamepad = GetInput().GetUserGamepad(GetUserManager().GetSelectedUser());
 if (gamepad > -1)
 {
 SelectUser(gamepad);
 }
 else
 {
 if (!m_IntroMenu && !(GetGame().GetUIManager().GetMenu() && GetGame().GetUIManager().GetMenu().GetID() == MENU_TITLE_SCREEN))
 CreateTitleScreen();
 GetGame().GetInput().IdentifyGamepad(GetGame().GetInput().GetEnterButton());
 }
 }
 else
 #endif
 {
 if (!m_IntroMenu && !(GetUIManager().GetMenu() && GetUIManager().GetMenu().GetID() == MENU_TITLE_SCREEN))
 CreateTitleScreen();
 GetInput().IdentifyGamepad(GetInput().GetEnterButton());
 }
 #endif
 #endif
 }
#endif
 }
 
 void SelectGamepad()
 {
 ResetProfileOptions();
 BiosUserManager user_manager = GetUserManager();
 
 if (user_manager)
 {
 BiosUser selected_user = user_manager.GetSelectedUser();
 if (selected_user)
 {
 OnlineServices.SetBiosUser(selected_user);
 SetPlayerName(selected_user.GetName());
 SetUserFOV(GetUserFOVFromConfig());
 #ifdef PLATFORM_CONSOLE
 SetPlayerGameName(selected_user.GetName());
 user_manager.GetUserDatabaseIdAsync();
 #endif
 }
 
 if (GetUIManager().GetMenu())
 {
 GetUIManager().GetMenu().Refresh();
 }
 }
 
 switch (GetLoadState())
 {
 case DayZLoadState.JOIN_USER_SELECT:
 {
 SetLoadState(DayZLoadState.JOIN_CONTROLLER_SELECT);
 OnlineServices.LoadMPPrivilege();
 break;
 }
 case DayZLoadState.PARTY_USER_SELECT:
 {
 SetLoadState(DayZLoadState.PARTY_CONTROLLER_SELECT);
 DeleteTitleScreen();
 GetUIManager().EnterScriptedMenu(MENU_SERVER_BROWSER, GetUIManager().GetMenu());
 break;
 }
 case DayZLoadState.CONNECT_USER_SELECT:
 {
 SetLoadState(DayZLoadState.CONNECT_CONTROLLER_SELECT);
 OnlineServices.LoadMPPrivilege();
 break;
 }
 case DayZLoadState.MAIN_MENU_USER_SELECT:
 {
 SetLoadState(DayZLoadState.MAIN_MENU_CONTROLLER_SELECT);
 DeleteTitleScreen();
 GetUIManager().EnterScriptedMenu(MENU_MAIN, GetUIManager().GetMenu());
 break;
 }
 case DayZLoadState.MISSION_USER_SELECT:
 {
 SetLoadState(DayZLoadState.MISSION_CONTROLLER_SELECT);
 DeleteTitleScreen();
 string mission;
 GetCLIParam("mission", mission);
 PlayMission(mission);
 break;
 }
 }
 }
 
 void TryConnect()
 {
 if (GetLoadState() == DayZLoadState.JOIN_CONTROLLER_SELECT)
 {
 SetGameState(DayZGameState.CONNECTING);
 OnlineServices.GetSession();
 }
 else
 {
 if (GetGameState() != DayZGameState.CONNECTING)
 {
 switch (GetLoadState())
 {
 case DayZLoadState.CONNECT_CONTROLLER_SELECT:
 {
 SetGameState(DayZGameState.CONNECTING);
 ConnectFromCLI();
 break;
 }
 case DayZLoadState.PARTY_CONTROLLER_SELECT:
 {
 SetGameState(DayZGameState.CONNECTING);
 Connect();
 break;
 }
 case DayZLoadState.MAIN_MENU_CONTROLLER_SELECT:
 {
 SetGameState(DayZGameState.CONNECTING);
 Connect();
 break;
 }
 }
 }
 else
 {
 string address;
 int port;
 if (GetHostAddress(address, port))
 {
 if (m_ConnectAddress == address && m_ConnectPort == port)
 ErrorModuleHandler.ThrowError(ErrorCategory.ConnectErrorScript, EConnectErrorScript.ALREADY_CONNECTING_THIS);
 else
 ErrorModuleHandler.ThrowError(ErrorCategory.ConnectErrorScript, EConnectErrorScript.ALREADY_CONNECTING, string.Format("%1:%2", address, port));
 }
 else 
 {
 DisconnectSessionForce();
 DisconnectSessionScript();
 TryConnect();
 }
 }
 }
 }
 
 bool GetLastVisitedServer(out string ip, out int port)
 {
 if (m_Visited)
 {
 if (m_Visited.Count() > 0)
 {
 string uid = m_Visited.Get(m_Visited.Count() - 1);
 TStringArray output = new TStringArray;
 uid.Split(":", output);
 ip = output[0];
 port = output[1].ToInt();
 return true;
 }
 }
 return false;
 }
 
 void AddVisitedServer(string ip, int port)
 {
 string uid = ip + ":" + port;
 if (m_Visited)
 {
 int pos = m_Visited.Find(uid);
 
 if (pos < 0)
 {
 if (m_Visited.Count() == MAX_VISITED)
 m_Visited.Remove(0);
 m_Visited.Insert(uid);
 }
 else
 {
 // if item is not saved as last server, move it
 if (pos != (m_Visited.Count() - 1))
 {
 m_Visited.Remove(pos);
 m_Visited.Insert(uid);
 }
 }
 SetProfileStringList("SB_Visited", m_Visited);
 SaveProfile();
 }
 }
 
 bool IsVisited(string ip, int port)
 {
 string uid = ip + ":" + port;
 int index = m_Visited.Find(uid);
 return (index >= 0);
 }
 
 void RefreshCurrentServerInfo()
 {
 string addr;
 int port;
 if (GetHostAddress(addr, port))
 {
 m_ConnectAddress = addr;
 m_ConnectPort = port;
 }
 OnlineServices.GetCurrentServerInfo(m_ConnectAddress, m_ConnectPort);
 }
 
 void Connect()
 {
 SetConnecting(true);
 
 DeleteTitleScreen();
 string addr;
 int port;
 if (GetHostAddress(addr, port))
 {
 if (m_ConnectAddress == addr && m_ConnectPort == port)
 return;
 }
 
 if (Connect(GetUIManager().GetMenu(), m_ConnectAddress, m_ConnectPort, m_ConnectPassword) != 0)
 DisconnectSessionScript(true);
 }
 
 void DisconnectSessionScript(bool displayJoinError = false)
 {
 DisconnectSessionFlags flags = DisconnectSessionFlags.SELECT_USER | DisconnectSessionFlags.IGNORE_WHEN_IN_GAME;
 if (displayJoinError)
 {
 flags |= DisconnectSessionFlags.JOIN_ERROR_ENABLED;
 flags |= DisconnectSessionFlags.JOIN_ERROR_CHECK;
 }
 
 DisconnectSessionEx(flags);
 }
 
 void DisconnectSessionEx(DisconnectSessionFlags flags)
 {
 if (flags & DisconnectSessionFlags.SELECT_USER && OnlineServices.GetBiosUser())
 {
 GetGame().GetUserManager().SelectUserEx(OnlineServices.GetBiosUser());
 }
 
 if (flags & DisconnectSessionFlags.JOIN_ERROR_ENABLED)
 {
 if (!(flags & DisconnectSessionFlags.JOIN_ERROR_CHECK) || GetGameState() == DayZGameState.JOIN)
 {
 NotificationSystem.AddNotification(NotificationType.JOIN_FAIL_GET_SESSION, NotificationSystem.DEFAULT_TIME_DISPLAYED);
 }
 }
 
 if (flags & DisconnectSessionFlags.IGNORE_WHEN_IN_GAME && GetGameState() == DayZGameState.IN_GAME)
 {
 return;
 }
 
 if (flags & DisconnectSessionFlags.CLOSE_MENUS && GetGame().GetUIManager())
 {
 GetGame().GetUIManager().CloseAllSubmenus();
 
 if ( GetGame().GetUIManager().IsDialogVisible() )
 {
 GetGame().GetUIManager().CloseDialog();
 }
 }
 
 if (flags & DisconnectSessionFlags.ALWAYS_FORCE)
 {
 DisconnectSessionForce();
 }
 
 if (GetGame().GetMission())
 {
 if (g_Game.GetGameState() != DayZGameState.MAIN_MENU)
 { 
 if (flags & DisconnectSessionFlags.DISCONNECT_ERROR_ENABLED)
 {
 NotificationSystem.AddNotification(NotificationType.DISCONNECTED, NotificationSystem.DEFAULT_TIME_DISPLAYED);
 }
 
 GetGame().GetMission().AbortMission();
 
 SetGameState(DayZGameState.MAIN_MENU);
 SetLoadState(DayZLoadState.MAIN_MENU_CONTROLLER_SELECT);
 
 GamepadCheck();
 }
 }
 
 else
 {
 MainMenuLaunch();
 }
 }
 
 void ConnectFromServerBrowser(string ip, int port, string password = "")
 {
 m_ConnectAddress = ip;
 m_ConnectPort = port;
 m_ConnectPassword = password;
 m_ConnectFromJoin = false;
 OnlineServices.LoadMPPrivilege();
 }
 
 void ConnectFromJoin(string ip, int port)
 {
 m_ConnectAddress = ip;
 m_ConnectPort = port;
 m_ConnectFromJoin = true;
 Connect();
 }
 
 void ConnectFromCLI()
 {
 string port;
 if (GetCLIParam("connect", m_ConnectAddress))
 {
 GetCLIParam("port", port);
 m_ConnectPort = port.ToInt();
 
 GetCLIParam("password", m_ConnectPassword);
 
 m_ConnectFromJoin = false;
 Connect();
 }
 }
 
 bool IsLeftCtrlDown()
 {
 return m_IsCtrlHolding;
 }
 
 // ------------------------------------------------------------
 override void OnKeyPress(int key)
 {
 
 if (key == KeyCode.KC_LCONTROL) 
 {
 m_IsCtrlHolding = true;
 }
 
 if (key == KeyCode.KC_LMENU)
 {
 m_IsLeftAltHolding = true;
 }
 
 if (key == KeyCode.KC_RMENU)
 {
 m_IsRightAltHolding = true;
 }
 
 if (m_keyboard_handler)
 {
 m_keyboard_handler.OnKeyDown(NULL, 0, 0, key);
 }
 
 Mission mission = GetMission();
 if (mission)
 {
 mission.OnKeyPress(key);
 }
 
#ifdef DEVELOPER
 if ((m_IsLeftAltHolding || m_IsLeftAltHolding) && key == KeyCode.KC_F4)
 {
 RequestExit(0);
 }
#endif
 
 }
 
 // ------------------------------------------------------------
 override void OnKeyRelease(int key)
 {
 if (key == KeyCode.KC_LCONTROL) 
 {
 m_IsCtrlHolding = false;
 }
 
 if (key == KeyCode.KC_LWIN) 
 {
 m_IsWinHolding = false;
 }
 
 if (key == KeyCode.KC_LMENU || key == KeyCode.KC_RMENU)
 {
 m_IsLeftAltHolding = false;
 }
 
 if (key == KeyCode.KC_RMENU)
 {
 m_IsRightAltHolding = false;
 }
 
 if (m_keyboard_handler)
 {
 m_keyboard_handler.OnKeyUp(NULL, 0, 0, key);
 }
 
 Mission mission = GetMission();
 if (mission)
 {
 mission.OnKeyRelease(key);
 }
 }
 
 // ------------------------------------------------------------ 
 override void OnMouseButtonPress(int button)
 {
 Mission mission = GetMission();
 if (mission)
 {
 mission.OnMouseButtonPress(button);
 }
 }
 
 // ------------------------------------------------------------
 override void OnMouseButtonRelease(int button)
 {
 Mission mission = GetMission();
 if (mission)
 {
 mission.OnMouseButtonRelease(button);
 }
 }
 
 // ------------------------------------------------------------
 override void OnDeviceReset()
 {
 m_IsCtrlHolding = false;
 m_IsWinHolding = false;
 m_IsLeftAltHolding = false;
 m_IsRightAltHolding = false;
 }
 
 // ------------------------------------------------------------
 float GetDeltaT()
 {
 return m_DeltaTime;
 }
 
 // ------------------------------------------------------------
 override void OnUpdate(bool doSim, float timeslice)
 {
 m_DeltaTime = timeslice;
 
 Mission mission = GetMission();
 bool gameIsRunning = false;
 
 if (doSim && mission && !mission.IsPaused())
 {
 gameIsRunning = true;
 }
 
 if (doSim && mission)
 {
 mission.OnUpdate(timeslice);
 }
 
 // queues and timers update
 GetCallQueue(CALL_CATEGORY_SYSTEM).Tick(timeslice);
 GetUpdateQueue(CALL_CATEGORY_SYSTEM).Invoke(timeslice);
 GetTimerQueue(CALL_CATEGORY_SYSTEM).Tick(timeslice);
 
 #ifndef NO_GUI 
 if (m_IsConnecting)
 UpdateLoginQueue(timeslice);
 
 if (m_loading && m_loading.IsLoading())
 {
 m_loading.OnUpdate(timeslice);
 }
 else if (m_LoginTimeScreen && m_LoginTimeScreen.IsStatic())
 {
 m_LoginTimeScreen.Update(timeslice);
 }
 else
 {
 GetCallQueue(CALL_CATEGORY_GUI).Tick(timeslice);
 GetUpdateQueue(CALL_CATEGORY_GUI).Invoke(timeslice);
 GetTimerQueue(CALL_CATEGORY_GUI).Tick(timeslice);
 GetDragQueue().Tick();
 }
 
 NotificationSystem.Update(timeslice);
 if (m_Notifications)
 {
 m_Notifications.Update(timeslice);
 }
 
 #ifndef SERVER
 #ifdef DIAG_DEVELOPER
 if (GetGame().IsMultiplayer() && GetPlayer() && DiagMenu.GetBool(DiagMenuIDs.MISC_CONNECTION_STATS))
 {
 PlayerIdentity playerIdentity = GetPlayer().GetIdentity();
 
 if (playerIdentity)
 {
 int pingAct = playerIdentity.GetPingAct();
 int pingAvg = playerIdentity.GetPingAvg();
 }
 
 DrawPerformaceStats(pingAct, pingAvg);
 }
 #endif
 #endif
 
 #endif
 
 if (gameIsRunning)
 {
 GetCallQueue(CALL_CATEGORY_GAMEPLAY).Tick(timeslice);
 GetUpdateQueue(CALL_CATEGORY_GAMEPLAY).Invoke(timeslice);
 GetTimerQueue(CALL_CATEGORY_GAMEPLAY).Tick(timeslice);
 }
 }
 
 // ------------------------------------------------------------
 override void OnPostUpdate(bool doSim, float timeslice)
 {
 Mission mission = GetMission();
 bool gameIsRunning = false;
 
 if (doSim && mission && !mission.IsPaused())
 {
 gameIsRunning = true;
 }
 
 GetPostUpdateQueue(CALL_CATEGORY_SYSTEM).Invoke(timeslice);
 
 #ifndef NO_GUI 
 if (m_loading && m_loading.IsLoading())
 {
 }
 else if (m_LoginTimeScreen && m_LoginTimeScreen.IsStatic())
 {
 }
 else
 {
 GetPostUpdateQueue(CALL_CATEGORY_GUI).Invoke(timeslice);
 }
 #endif
 
 if (gameIsRunning)
 {
 GetPostUpdateQueue(CALL_CATEGORY_GAMEPLAY).Invoke(timeslice);
 }
 }
 
 // ------------------------------------------------------------
 override void OnRPC(PlayerIdentity sender, Object target, int rpc_type, ParamsReadContext ctx)
 {
 super.OnRPC(sender, target, rpc_type, ctx);
 Event_OnRPC.Invoke(sender, target, rpc_type, ctx);
 
 //Print("["+ GetGame().GetTime().ToString() +"] => DayZGame::OnRPC = "+ EnumTools.EnumToString(ERPCs,rpc_type));
 
 if (target)
 {
 // call rpc on target
 target.OnRPC(sender, rpc_type, ctx);
 }
 else
 {
 switch (rpc_type)
 {
 #ifndef SERVER
 #ifndef NO_GUI
 case ERPCs.RPC_CFG_GAMEPLAY_SYNC:
 {
 CfgGameplayHandler.OnRPC(null, ctx);
 break;
 }
 case ERPCs.RPC_UNDERGROUND_SYNC:
 {
 UndergroundAreaLoader.OnRPC(ctx);
 break;
 }
 case ERPCs.RPC_SEND_NOTIFICATION:
 {
 NotificationType type;
 float show_time;
 string detail_text;
 
 ctx.Read(type);
 ctx.Read(show_time);
 ctx.Read(detail_text);
 
 NotificationSystem.AddNotification(type, show_time, detail_text);
 break;
 }
 case ERPCs.RPC_SEND_NOTIFICATION_EXTENDED:
 {
 float show_time_ext;
 string title_text_ext;
 string detail_text_ext;
 string icon_ext;
 
 ctx.Read(show_time_ext);
 ctx.Read(title_text_ext);
 ctx.Read(detail_text_ext);
 ctx.Read(icon_ext);
 
 NotificationSystem.AddNotificationExtended(show_time_ext, title_text_ext, detail_text_ext, icon_ext);
 break;
 }
 
 
 case ERPCs.RPC_SOUND_HELICRASH:
 {
 bool playSound;
 vector pos;
 string sound_set;
 
 //Helicrash is a world event, we want anyone to be able to hear it
 Param3<bool, vector, int> playCrashSound = new Param3<bool, vector, int>(false, "0 0 0",0);
 if (ctx.Read(playCrashSound))
 {
 playSound = playCrashSound.param1;
 pos = playCrashSound.param2;
 sound_set = CrashSoundSets.GetSoundSetByHash(playCrashSound.param3);
 }
 
 if (playSound)
 {
 m_CrashSound = SEffectManager.PlaySound(sound_set, pos, 0.1, 0.1);
 m_CrashSound.SetAutodestroy(true);
 }
 
 break;
 }
 //Random off map artillery barrage
 case ERPCs.RPC_SOUND_ARTILLERY:
 {
 vector position;
 Param1<vector> playArtySound = new Param1<vector>(vector.Zero);
 if (ctx.Read(playArtySound))
 {
 position = playArtySound.param1;
 if (position == vector.Zero)
 break;
 }
 else
 break;
 
 if (!GetGame().GetPlayer())
 break;
 
 if (vector.DistanceSq(GetGame().GetPlayer().GetPosition(), position) <= (MIN_ARTY_SOUND_RANGE * MIN_ARTY_SOUND_RANGE))
 break;
 
 m_ArtySound = SEffectManager.PlaySound("Artillery_Distant_Barrage_SoundSet", position, 0.1, 0.1);
 m_ArtySound.SetAutodestroy(true);
 
 break;
 }
 case ERPCs.RPC_SOUND_CONTAMINATION:
 {
 vector soundPos;
 
 Param1<vector> playContaminatedSound = new Param1<vector>(vector.Zero);
 if (ctx.Read(playContaminatedSound))
 {
 soundPos = playContaminatedSound.param1;
 if (soundPos == vector.Zero)
 break;
 }
 else
 break;
 
 if (!GetGame().GetPlayer())
 break;
 
 EffectSound closeArtySound = SEffectManager.PlaySound("Artillery_Close_SoundSet", soundPos);
 closeArtySound.SetAutodestroy(true);
 
 // We add camera shake upon shell detonation
 float distance_to_player = vector.DistanceSq(soundPos, GetGame().GetPlayer().GetPosition());
 if (distance_to_player <= GameConstants.CAMERA_SHAKE_ARTILLERY_DISTANCE2)
 {
 float strength_factor = Math.InverseLerp(GameConstants.CAMERA_SHAKE_ARTILLERY_DISTANCE, 0, Math.Sqrt(distance_to_player));
 DayZPlayerCamera camera = GetGame().GetPlayer().GetCurrentCamera();
 if (camera)
 camera.SpawnCameraShake(strength_factor * 4);
 }
 
 ParticleManager.GetInstance().PlayInWorld(ParticleList.CONTAMINATED_AREA_GAS_SHELL, soundPos);
 break;
 }
 // Single artillery shot to announce dynamic contaminated area
 case ERPCs.RPC_SOUND_ARTILLERY_SINGLE:
 {
 vector soundPosition;
 vector delayedSoundPos;
 float soundDelay;
 
 Param3<vector, vector, float> playArtyShotSound = new Param3<vector, vector, float>(vector.Zero, vector.Zero, 0);
 if (ctx.Read(playArtyShotSound))
 {
 soundPosition = playArtyShotSound.param1;
 delayedSoundPos = playArtyShotSound.param2;
 soundDelay = playArtyShotSound.param3;
 if (soundPosition == vector.Zero)
 break;
 }
 else
 break;
 
 if (!GetGame().GetPlayer())
 break;
 
 m_ArtySound = SEffectManager.PlaySound("Artillery_Distant_SoundSet", soundPosition, 0.1, 0.1);
 m_ArtySound.SetAutodestroy(true);
 
 // We remove the amount of time the incoming sound lasts
 soundDelay -= 5;
 // We convert to milliseconds
 soundDelay *= 1000;
 GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(DelayedMidAirDetonation, soundDelay, false, delayedSoundPos[0], delayedSoundPos[1], delayedSoundPos[2]);
 break;
 }
 case ERPCs.RPC_SET_BILLBOARDS:
 {
 if (!m_BillboardSetHandler)
 m_BillboardSetHandler = new BillboardSetHandler();
 
 Param1<int> indexP = new Param1<int>(-1);
 if (ctx.Read(indexP))
 {
 int index = indexP.param1;
 m_BillboardSetHandler.OnRPCIndex(index);
 }
 break;
 }
 #endif
 #endif
 
 case ERPCs.RPC_USER_SYNC_PERMISSIONS:
 {
 map<string, bool> mute_list;
 if (ctx.Read(mute_list))
 {
 for (int i = 0; i < mute_list.Count(); i++)
 {
 string uid = mute_list.GetKey(i);
 bool mute = mute_list.GetElement(i);
 MutePlayer(uid, sender.GetPlainId(), mute);
 }
 }
 break;
 }
 
 /*
 case ERPCs.RPC_SERVER_RESPAWN_MODE:
 {
 int mode;
 if (ctx.Read(mode) && !IsServer())
 {
 GetMission().SetRespawnModeClient(mode);
 }
 }
 */
 
 #ifdef DEVELOPER
 case ERPCs.DEV_SET_WEATHER:
 {
 Param1<DebugWeatherRPCData> p1data = new Param1<DebugWeatherRPCData>(null);
 
 if ( ctx.Read(p1data) )
 {
 DebugWeatherRPCData data = p1data.param1;
 
 if (data.m_FogValue >= 0)
 GetGame().GetWeather().GetFog().Set(data.m_FogValue, data.m_FogInterpolation, data.m_FogDuration);
 
 if (data.m_OvercastValue >= 0)
 GetGame().GetWeather().GetOvercast().Set(data.m_OvercastValue, data.m_OvercastInterpolation, data.m_OvercastDuration);
 
 if (data.m_RainValue >= 0)
 GetGame().GetWeather().GetRain().Set(data.m_RainValue, data.m_RainInterpolation, data.m_RainDuration);
 
 }
 else
 {
 ErrorEx("Failed to read weather debug data");
 }
 break;
 }
 #endif
 
 
 #ifdef DIAG_DEVELOPER
 #ifdef SERVER
 case ERPCs.DIAG_CAMERATOOLS_CAM_DATA:
 {
 if (!m_CameraToolsMenuServer)
 {
 m_CameraToolsMenuServer = new CameraToolsMenuServer;
 }
 m_CameraToolsMenuServer.OnRPC(rpc_type, ctx);
 break;
 }
 
 case ERPCs.DIAG_CAMERATOOLS_CAM_SUBSCRIBE:
 {
 if (!m_CameraToolsMenuServer)
 {
 m_CameraToolsMenuServer = new CameraToolsMenuServer;
 }
 m_CameraToolsMenuServer.OnRPC(rpc_type, ctx);
 break;
 }
 
 #endif
 #endif
 
 }
 // global rpc's handling
 }
 }
 
 void DelayedMidAirDetonation(float x, float y, float z)
 {
 EffectSound artilleryFallSound = SEffectManager.PlaySound("Artillery_Fall_SoundSet", Vector(x, y, z));
 artilleryFallSound.SetAutodestroy(true);
 }
 
 // ------------------------------------------------------------
 void CheckDialogs()
 {
 #ifndef NO_GUI 
 Mission mission = GetMission();
 if (mission && !m_loading.IsLoading() && GetUIManager().IsDialogQueued())
 {
 mission.Pause();
 GetUIManager().ShowQueuedDialog();
 }
 #endif
 }
 
 void SetConnecting(bool value)
 {
 m_IsConnecting = value;
 }
 
 bool IsConnecting()
 {
 return m_IsConnecting;
 }
 
 // ------------------------------------------------------------
 bool IsLoading()
 {
 return m_loading && m_loading.IsLoading();
 }
 
 // ------------------------------------------------------------
 void SetKeyboardHandle(UIScriptedMenu handler)
 {
 m_keyboard_handler = handler;
 }
 
 // ------------------------------------------------------------
 void LoadingShow()
 {
 #ifndef NO_GUI 
 m_loading.ShowEx(this);
 #endif
 }
 
 // ------------------------------------------------------------
 void LoadingHide(bool force = false)
 {
 #ifndef NO_GUI
 m_loading.Hide(force);
 // turn the lights back on
 PPEManagerStatic.GetPPEManager().StopAllEffects();
 #ifdef PLATFORM_CONSOLE
 if (!IsLoading())
 {
 if (m_LoadState != DayZLoadState.MAIN_MENU_START && m_LoadState != DayZLoadState.MAIN_MENU_USER_SELECT)
 {
 UpdateInputDeviceDisconnectWarning();
 }
 }
 #endif
 #endif
 }
 
 // ------------------------------------------------------------
 override string CreateDefaultPlayer()
 { 
 if (m_CharClassNames.Count() > 0)
 return m_CharClassNames[0];
 
 return "";
 }
 
 // ------------------------------------------------------------
 override string CreateRandomPlayer()
 {
 return m_CharClassNames.GetRandomElement();
 }
 
 // ------------------------------------------------------------
 override TStringArray ListAvailableCharacters()
 {
 return m_CharClassNames;
 }
 
 // ------------------------------------------------------------
 void ExplosionEffectsEx(Object source, Object directHit, int componentIndex, float energyFactor, float explosionFactor, HitInfo hitInfo)
 {
 vector pos = hitInfo.GetPosition();
 string ammoType = hitInfo.GetAmmoType();
 
 // Call legacy method
 ExplosionEffects(source, directHit, componentIndex, hitInfo.GetSurface(), pos, hitInfo.GetSurfaceNormal(), energyFactor, explosionFactor, hitInfo.IsWater(), ammoType);
 
 // add explosion noise
 if (IsServer())
 {
 //NoiseParams npar = new NoiseParams();
 m_NoiseParams.LoadFromPath(string.Format("cfgAmmo %1 NoiseExplosion", ammoType));
 
 GetNoiseSystem().AddNoiseTarget(pos, 21, m_NoiseParams, hitInfo.GetSurfaceNoiseMultiplier());
 }
 }
 
 // ------------------------------------------------------------
 void ExplosionEffects(Object source, Object directHit, int componentIndex, string surface, vector pos, vector surfNormal,
 float energyFactor, float explosionFactor, bool isWater, string ammoType)
 {
 #ifndef SERVER
 if (source)
 {
 source.OnExplosionEffects(source, directHit, componentIndex, surface, pos, surfNormal, energyFactor, explosionFactor, isWater, ammoType);
 
 if (source.ShootsExplosiveAmmo() && ammoType == "Explosion_40mm_Ammo")
 ParticleManager.GetInstance().PlayInWorld(ParticleList.EXPLOSION_LANDMINE, pos);
 
 float distance_to_player = vector.Distance(pos, GetGame().GetPlayer().GetPosition());
 m_AmmoShakeParams.Load(ammoType);
 
 if (distance_to_player < m_AmmoShakeParams.m_Radius)
 {
 float dist01 = Math.InverseLerp(0, m_AmmoShakeParams.m_Radius, distance_to_player);
 float modifier = Math.Lerp(m_AmmoShakeParams.m_ModifierClose, m_AmmoShakeParams.m_ModifierFar,dist01);
 
 GetGame().GetPlayer().GetCurrentCamera().SpawnCameraShake(modifier * m_AmmoShakeParams.m_Strength);
 }
 }
 #endif
 }
 
 // ------------------------------------------------------------
 void OnProjectileStopped(ProjectileStoppedInfo info)
 {
 string simulation;
 
 GetGame().ConfigGetText("cfgAmmo " + info.GetAmmoType() + " simulation", simulation); 
 
 if (simulation == "shotArrow")
 {
 string pile;
 
 GetGame().ConfigGetText("cfgAmmo " + info.GetAmmoType() + " spawnPileType", pile);
 
 EntityAI arrow = EntityAI.Cast(GetGame().CreateObjectEx(pile, info.GetPos(), ECE_DYNAMIC_PERSISTENCY));
 arrow.PlaceOnSurface(); 
 arrow.SetFromProjectile(info);
 }
 }
 
 const float ARROW_PIERCE_DEPTH = 0.05;
 
 // ------------------------------------------------------------
 void OnProjectileStoppedInTerrain(TerrainCollisionInfo info)
 {
 string simulation;
 
 if (info.GetIsWater())
 return;
 
 GetGame().ConfigGetText("cfgAmmo " + info.GetAmmoType() + " simulation", simulation);
 if (simulation == "shotArrow")
 {
 string pile;
 GetGame().ConfigGetText("cfgAmmo " + info.GetAmmoType() + " spawnPileType", pile);
 vector pos = info.GetPos();
 vector dir = -info.GetInVelocity();
 
 dir.Normalize();
 pos -= dir * ARROW_PIERCE_DEPTH;
 
 EntityAI arrow = EntityAI.Cast(GetGame().CreateObjectEx(pile, pos, ECE_KEEPHEIGHT|ECE_DYNAMIC_PERSISTENCY));
 arrow.SetDirection(dir);
 arrow.SetFromProjectile(info);
 }
 }
 
 // ------------------------------------------------------------
 void OnProjectileStoppedInObject(ObjectCollisionInfo info)
 {
 string simulation;
 
 GetGame().ConfigGetText("cfgAmmo " + info.GetAmmoType() + " simulation", simulation); 
 if (simulation == "shotArrow")
 {
 string pile;
 GetGame().ConfigGetText("cfgAmmo " + info.GetAmmoType() + " spawnPileType", pile);
 
 EntityAI arrow = null;
 EntityAI ent = EntityAI.Cast(info.GetHitObj());
 if (ent)
 {
 EntityAI parent = ent.GetHierarchyParent();
 if (parent && parent.IsPlayer())
 {
 arrow = EntityAI.Cast(GetGame().CreateObjectEx(pile, parent.GetPosition(), ECE_DYNAMIC_PERSISTENCY));
 arrow.PlaceOnSurface(); 
 arrow.SetFromProjectile(info);
 
 return;
 }
 }
 
 vector pos = info.GetPos();
 vector dir = -info.GetInVelocity();
 
 dir.Normalize();
 pos -= dir * ARROW_PIERCE_DEPTH;
 
 arrow = EntityAI.Cast(GetGame().CreateObjectEx(pile, pos, ECE_KEEPHEIGHT|ECE_DYNAMIC_PERSISTENCY));
 arrow.SetDirection(dir);
 arrow.SetFromProjectile(info);
 
 info.GetHitObj().AddArrow(arrow, info.GetComponentIndex(), info.GetHitObjPos(), info.GetHitObjRot());
 }
 }
 
 // ------------------------------------------------------------
 void FirearmEffects(Object source, Object directHit, int componentIndex, string surface, vector pos, vector surfNormal,
 vector exitPos, vector inSpeed, vector outSpeed, bool isWater, bool deflected, string ammoType) 
 {
 #ifndef SERVER
 ImpactEffectsData impactEffectsData = new ImpactEffectsData();
 impactEffectsData.m_DirectHit = directHit;
 impactEffectsData.m_ComponentIndex = componentIndex;
 impactEffectsData.m_Surface = surface;
 impactEffectsData.m_Position = pos;
 impactEffectsData.m_ImpactType = ImpactTypes.UNKNOWN;
 impactEffectsData.m_SurfaceNormal = surfNormal;
 impactEffectsData.m_ExitPosition = exitPos;
 impactEffectsData.m_InSpeed = inSpeed;
 impactEffectsData.m_OutSpeed = outSpeed;
 impactEffectsData.m_IsDeflected = deflected;
 impactEffectsData.m_AmmoType = ammoType;
 impactEffectsData.m_IsWater = isWater;
 
 if (directHit)
 {
 directHit.OnReceivedHit(impactEffectsData);
 }
 
 ImpactMaterials.EvaluateImpactEffectEx(impactEffectsData);
 #endif
 
 
 if (IsServer())
 {
 if (source && source.ShootsExplosiveAmmo() && !deflected && outSpeed == vector.Zero)
 {
 if (ammoType == "Bullet_40mm_ChemGas")
 {
 GetGame().CreateObject("ContaminatedArea_Local", pos);
 }
 else if (ammoType == "Bullet_40mm_Explosive")
 {
 DamageSystem.ExplosionDamage(EntityAI.Cast(source), null, "Explosion_40mm_Ammo", pos, DamageType.EXPLOSION);
 }
 }
 
 // add hit noise
 m_NoiseParams.LoadFromPath("cfgAmmo " + ammoType + " NoiseHit");
 
 float surfaceCoef = SurfaceGetNoiseMultiplier(directHit, pos, componentIndex);
 float coefAdjusted = surfaceCoef * inSpeed.Length() / ConfigGetFloat("cfgAmmo " + ammoType + " initSpeed");
 GetNoiseSystem().AddNoiseTarget(pos, 10, m_NoiseParams, coefAdjusted); // Leave a ping for 5 seconds
 }
 }
 
 // ------------------------------------------------------------
 void CloseCombatEffects(Object source, Object directHit, int componentIndex, string surface, vector pos, vector surfNormal,
 bool isWater, string ammoType) 
 {
 #ifndef SERVER
 ImpactEffectsData impactEffectsData = new ImpactEffectsData();
 impactEffectsData.m_DirectHit = directHit;
 impactEffectsData.m_ComponentIndex = componentIndex;
 impactEffectsData.m_Surface = surface;
 impactEffectsData.m_Position = pos;
 impactEffectsData.m_ImpactType = ImpactTypes.MELEE;
 impactEffectsData.m_SurfaceNormal = Vector(Math.RandomFloat(-1,1), Math.RandomFloat(-1,1), Math.RandomFloat(-1,1));
 impactEffectsData.m_ExitPosition = "0 0 0";
 impactEffectsData.m_InSpeed = "0 0 0";
 impactEffectsData.m_OutSpeed = "0 0 0";
 impactEffectsData.m_IsDeflected = false;
 impactEffectsData.m_AmmoType = ammoType;
 impactEffectsData.m_IsWater = isWater;
 
 if (directHit)
 directHit.OnReceivedHit(impactEffectsData);
 
 ImpactMaterials.EvaluateImpactEffectEx(impactEffectsData);
 #endif
 
 // add hit noise
 if (IsServer())
 {
 m_NoiseParams.LoadFromPath("cfgAmmo " + ammoType + " NoiseHit");
 
 float surfaceCoef = SurfaceGetNoiseMultiplier(directHit, pos, componentIndex);
 GetNoiseSystem().AddNoisePos(EntityAI.Cast(source), pos, m_NoiseParams, surfaceCoef);
 }
 }
 
 void UpdateVoiceLevel(int level)
 {
 GetMission().UpdateVoiceLevelWidgets(level); 
 }
 
 void InitCharacterMenuDataInfo(int menudata_count)
 {
 m_OriginalCharactersCount = menudata_count;
 }
 
 void SetPlayerGameName(string name)
 {
 m_PlayerName = name;
 }
 
 string GetPlayerGameName()
 {
 return m_PlayerName;
 }
 
 void SetNewCharacter(bool state)
 {
 m_IsNewCharacter = state;
 }
 
 bool IsNewCharacter()
 {
 return m_IsNewCharacter;
 }
 
 void SetUserFOV(float pFov)
 {
 if (pFov < OPTIONS_FIELD_OF_VIEW_MIN)
 pFov = OPTIONS_FIELD_OF_VIEW_MIN;
 
 if (pFov > OPTIONS_FIELD_OF_VIEW_MAX)
 pFov = OPTIONS_FIELD_OF_VIEW_MAX;
 
 m_UserFOV = pFov;
 }
 
 float GetUserFOV()
 {
 return m_UserFOV;
 }
 
 static float GetUserFOVFromConfig()
 {
 GameOptions gameOptions = new GameOptions;
 NumericOptionsAccess noa;
 if (gameOptions && Class.CastTo(noa,gameOptions.GetOptionByType(OptionAccessType.AT_OPTIONS_FIELD_OF_VIEW)))
 {
 return noa.ReadValue();
 }
 return 1.0;
 }
 
 float GetFOVByZoomType(ECameraZoomType type)
 {
 switch (type)
 {
 case ECameraZoomType.NONE:
 return GetUserFOV();
 case ECameraZoomType.NORMAL:
 return Math.Min(GetUserFOV(), GameConstants.DZPLAYER_CAMERA_FOV_EYEZOOM);
 case ECameraZoomType.SHALLOW:
 return Math.Min(GetUserFOV(),GameConstants.DZPLAYER_CAMERA_FOV_EYEZOOM_SHALLOW);
 default:
 return GetUserFOV();
 }
 return GetUserFOV();
 }
 
 void SetHudBrightness(float value)
 {
 Widget.SetLV(value);
 Widget.SetTextLV(value);
 }
 
 float GetHUDBrightnessSetting()
 {
 return g_Game.GetProfileOptionFloat(EDayZProfilesOptions.HUD_BRIGHTNESS);
 }
 
 // Check if ammo is compatible with a weapon in hands 
 static bool CheckAmmoCompability(EntityAI weaponInHand, EntityAI ammo)
 { 
 TStringArray ammo_names = new TStringArray; // Array of ammo types (their name) that can be used with weapon in hand
 
 string cfg_path = "CfgWeapons " + weaponInHand.GetType() + " chamberableFrom"; // Create config path 
 GetGame().ConfigGetTextArray(cfg_path, ammo_names); // Get ammo types 
 
 foreach (string ammo_name : ammo_names) // for every ammo in ammo string compare passed ammo 
 {
 if (ammo.GetType() == ammo_name) 
 {
 return true; 
 }
 }
 
 // if no ammo from the array matches with ammo passed, return false 
 return false;
 }
 
 void SetEVValue(float value)
 {
 m_PreviousEVValue = m_EVValue;
 SetEVUser(value);
 m_EVValue = value;
 }
 
 float GetCurrentEVValue()
 {
 return m_EVValue;
 }
 
 float GetPreviousEVValue()
 {
 return m_PreviousEVValue;
 }
 
 int GetCurrentDisplayLanguageIdx()
 {
 ListOptionsAccess language_option;
 GameOptions options = new GameOptions();
 language_option = ListOptionsAccess.Cast(options.GetOptionByType(OptionAccessType.AT_OPTIONS_LANGUAGE));
 int idx = -1;
 if (language_option)
 {
 idx = language_option.GetIndex();
 }
 
 return idx;
 }
 
 bool IsWorldWetTempUpdateEnabled()
 {
 return m_IsWorldWetTempUpdateEnabled;
 }
 
 bool IsFoodDecayEnabled()
 {
 return (GetFoodDecayModifier() != 0);
 } 
 
 float GetFoodDecayModifier()
 {
 #ifdef DIAG_DEVELOPER
 
 if (FeatureTimeAccel.GetFeatureTimeAccelEnabled(ETimeAccelCategories.FOOD_DECAY))
 {
 return m_FoodDecayModifier * FeatureTimeAccel.GetFeatureTimeAccelValue();
 }
 #endif
 return m_FoodDecayModifier;
 }
 
 array<int> GetConnectedInputDeviceList()
 {
 if (!m_ConnectedInputDeviceList)
 {
 m_ConnectedInputDeviceList = new array<int>;
 }
 return m_ConnectedInputDeviceList;
 }
 
 void SetMouseCursorDesiredVisibility(bool visible)
 {
 m_CursorDesiredVisibilityScript = visible;
 
 RefreshMouseCursorVisibility();
 }
 
 bool GetMouseCursorDesiredVisibility()
 {
 return m_CursorDesiredVisibilityScript;
 }
 
 bool CanDisplayMouseCursor()
 {
#ifdef PLATFORM_CONSOLE
 if (GetInput())
 {
 return GetInput().IsMouseConnected();
 }
#endif
 
#ifdef PLATFORM_CONSOLE
 return false;
#else
 return true;
#endif
 }
 
 void RefreshMouseCursorVisibility()
 {
#ifndef NO_GUI
#ifdef FEATURE_CURSOR
 if (!IsAppActive())
 {
 ShowCursorWidget(true);
 }
 else
#endif
 {
 bool showCursor = m_CursorDesiredVisibilityScript && CanDisplayMouseCursor();
 
 UIManager ui = GetUIManager();
 if (ui)
 {
 ui.ShowCursor(showCursor);
 }
 else
 {
 ShowCursorWidget(showCursor);
 }
 }
#endif
 }
 
 BillboardSetHandler GetBillboardHandler()
 {
 return m_BillboardSetHandler;
 }
 
 //DEPRECATED//
 void CreateGamepadDisconnectMenu();
 void DeleteGamepadDisconnectMenu();
};
 
DayZGame g_Game;
 
DayZGame GetDayZGame()
{
 return g_Game;
}