Game.c

Go to the documentation of this file.

 
static int GAME_STORAGE_VERSION = 135;
 
class CGame
{
  // enableDebugMonitor in server config
  int m_DebugMonitorEnabled;
 
  ScriptModule GameScript;
 
  private ref array<ref Param> m_ParamCache;
 
  //analytics
  ref AnalyticsManagerServer m_AnalyticsManagerServer;
  ref AnalyticsManagerClient m_AnalyticsManagerClient;
  ref MenuDefaultCharacterData m_CharacterData;
 
#ifdef DIAG_DEVELOPER
  ref array<ComponentEnergyManager> m_EnergyManagerArray;
  void EnableEMPlugs(bool enable)
  {
    for (int i = 0; i < GetGame().m_EnergyManagerArray.Count(); ++i)
    {
      if (GetGame().m_EnergyManagerArray[i])
        GetGame().m_EnergyManagerArray[i].SetDebugPlugs(enable);
    }
  }
#endif
 
  void CGame()
  {
    Math.Randomize(-1);
 
    LogManager.Init();
    m_ParamCache = new array<ref Param>;
    m_ParamCache.Insert(null);
 
    //analytics
    m_AnalyticsManagerServer = new AnalyticsManagerServer;
    m_AnalyticsManagerClient = new AnalyticsManagerClient;
 
    //m_CharacterData = new MenuCharacrerData;
 
    // actual script version - increase by one when you make changes
    StorageVersion(GAME_STORAGE_VERSION);
 
#ifdef DIAG_DEVELOPER
    m_EnergyManagerArray = new array<ComponentEnergyManager>;
#endif
 
    if (!IsDedicatedServer())
    {
      SEffectManager.Init();
      AmmoEffects.Init();
      VONManager.Init();
    }
  }
 
  private void ~CGame()
  {
    // Clean these up even if it is dedicated server, just to be safe
    SEffectManager.Cleanup();
    AmmoEffects.Cleanup();
    VONManager.CleanupInstance();
 
    // Is initialized in StartupEvent
    ParticleManager.CleanupInstance();
  }
 
  proto native WorkspaceWidget GetWorkspace();
  proto native WorkspaceWidget GetLoadingWorkspace();
 
 
  void OnEvent(EventType eventTypeId, Param params)
  {
  }
 
  //PLM Type: 0 == RESUMED, 1 == SUSPENDED
  void OnProcessLifetimeChanged(int plmtype)
  {
 
  }
 
  void OnLicenseChanged()
  {
 
  }
 
  void OnAfterCreate()
  {
  }
 
  void OnActivateMessage()
  {
  }
 
  void OnDeactivateMessage()
  {
  }
 
  bool OnInitialize()
  {
    return false;
  }
 
  void OnDeviceReset()
  {
  }
 
  void OnUpdate(bool doSim, float timeslice)
  {
  }
 
  void OnPostUpdate(bool doSim, float timeslice)
  {
  }
 
  void OnKeyPress(int key)
  {
  }
 
  void OnKeyRelease(int key)
  {
  }
 
  void OnMouseButtonPress(int button)
  {
  }
 
  void OnMouseButtonRelease(int button)
  {
  }
 
  UIScriptedMenu CreateScriptedMenu(int id) { }
 
  UIScriptedWindow CreateScriptedWindow(int id) { }
 
  void OnRPC(PlayerIdentity sender, Object target, int rpc_type, ParamsReadContext ctx)
  {
  }
 
  proto native void RequestExit(int code);
 
  proto native void RequestRestart(int code);
 
  proto native bool IsAppActive();
 
  proto bool GetHostAddress(out string address, out int port);
 
  proto owned string GetHostName();
 
  proto GetServersResultRow GetHostData();
 
  proto native int Connect(UIScriptedMenu parent, string IpAddress, int port, string password);
  proto native int ConnectLastSession(UIScriptedMenu parent, int selectedCharacter = -1);
  proto native void DisconnectSession();
 
  proto native void DisconnectSessionForce();
 
  // profile functions
  proto native void GetProfileStringList(string name, out TStringArray values);
 
  proto bool GetProfileString(string name, out string value);
 
  proto native void SetProfileStringList(string name, TStringArray values);
 
  proto native void SetProfileString(string name, string value);
 
  proto native void SaveProfile();
 
  proto void GetPlayerName(out string name);
 
  proto void GetPlayerNameShort(int maxLength, out string name);
 
  proto native void SetPlayerName(string name);
 
  proto native Entity CreatePlayer(PlayerIdentity identity, string name, vector pos, float radius, string spec);
 
  proto native void SelectPlayer(PlayerIdentity identity, Object player);
 
  proto void GetPlayerNetworkIDByIdentityID(int playerIdentityID, out int networkIdLowBits, out int networkIdHightBits);
 
  proto native Object GetObjectByNetworkId(int networkIdLowBits, int networkIdHighBits);
 
  proto native bool RegisterNetworkStaticObject(Object object);
 
  proto native void SelectSpectator(PlayerIdentity identity, string spectatorObjType, vector position);
 
  proto native void UpdateSpectatorPosition(vector position);
 
  proto native void SendLogoutTime(Object player, int time);
 
  proto native void DisconnectPlayer(PlayerIdentity identity, string uid = "");
 
  proto native void AddToReconnectCache(PlayerIdentity identity);
 
  proto native void RemoveFromReconnectCache(string uid);
 
  proto native void ClearReconnectCache();
 
 
  proto native void StorageVersion(int iVersion);
 
  proto native int LoadVersion();
 
  proto native int SaveVersion();
 
  proto native float GetDayTime();
 
  // config functions
  proto bool ConfigGetText(string path, out string value);
 
  proto bool ConfigGetTextRaw(string path, out string value);
 
  string ConfigGetTextOut(string path)
  {
    string ret_s;
    ConfigGetText(path, ret_s);
    return ret_s;
  }
 
  bool FormatRawConfigStringKeys(inout string value)
  {
    int ret;
    ret = value.Replace("$STR_", "#STR_");
    return ret > 0;
  }
 
  string GetModelName(string class_name)
  {
    if (class_name != "")
    {
      string cfg = "CfgVehicles " + class_name + " model";
      string model_path;
      if (GetGame().ConfigGetText(cfg, model_path))
      {
        int to_substring_end = model_path.Length() - 4; // -4 to leave out the '.p3d' suffix
        int to_substring_start = 0;
 
        // Currently we have model path. To get the name out of it we need to parse this string from the end and stop at the first found '\' sign
        for (int i = to_substring_end; i > 0; i--)
        {
          string sign = model_path.Get(i);
          if (sign == "\\")
          {
            to_substring_start = i + 1;
            break
          }
        }
 
        string model_name = model_path.Substring(to_substring_start, to_substring_end - to_substring_start);
        return model_name;
      }
    }
 
    return "UNKNOWN_P3D_FILE";
  }
 
  proto native float ConfigGetFloat(string path);
 
 
  proto native vector ConfigGetVector(string path);
 
  proto native int ConfigGetInt(string path);
 
  proto native int ConfigGetType(string path);
 
  proto native void ConfigGetTextArray(string path, out TStringArray values);
 
  proto native void ConfigGetTextArrayRaw(string path, out TStringArray values);
 
  proto native void ConfigGetFloatArray(string path, out TFloatArray values);
 
  proto native void ConfigGetIntArray(string path, out TIntArray values);
 
  proto bool ConfigGetChildName(string path, int index, out string name);
 
  proto bool ConfigGetBaseName(string path, out string base_name);
 
  proto native int ConfigGetChildrenCount(string path);
  proto native bool ConfigIsExisting(string path);
 
  proto native void ConfigGetFullPath(string path, out TStringArray full_path);
  proto native void ConfigGetObjectFullPath(Object obj, out TStringArray full_path);
 
  proto native void GetModInfos(notnull out array<ref ModInfo> modArray);
  proto native bool GetModToBeReported();
 
  string ConfigPathToString(TStringArray array_path)
  {
    string return_path = "";
    int count = array_path.Count();
 
    for (int i = 0; i < count; i++)
    {
      return_path += array_path.Get(i);
 
      if (i < count - 1)
        return_path += " ";
    }
 
    return return_path;
  }
 
  proto bool CommandlineGetParam(string name, out string value);
 
  proto native void CopyToClipboard(string text);
  proto void CopyFromClipboard(out string text);
 
  proto native void BeginOptionsVideo();
  proto native void EndOptionsVideo();
 
  proto native void AdminLog(string text);
 
  // entity functions
  proto native bool PreloadObject(string type, float distance);
 
  proto native Object CreateStaticObjectUsingP3D(string p3dFilename, vector position, vector orientation, float scale = 1.0, bool createLocal = false);
 
  proto native Object CreateObject(string type, vector pos, bool create_local = false, bool init_ai = false, bool create_physics = true);
  proto native SoundOnVehicle CreateSoundOnObject(Object source, string sound_name, float distance, bool looped, bool create_local = false);
  proto native SoundWaveOnVehicle CreateSoundWaveOnObject(Object source, SoundObject soundObject, AbstractWave soundWave);
 
  proto native Object CreateObjectEx(string type, vector pos, int iFlags, int iRotation = RF_DEFAULT);
 
  proto native void ObjectDelete(Object obj);
  proto native void ObjectDeleteOnClient(Object obj);
  proto native void RemoteObjectDelete(Object obj); 
  proto native void RemoteObjectTreeDelete(Object obj); 
  proto native void RemoteObjectCreate(Object obj); 
  proto native void RemoteObjectTreeCreate(Object obj); 
  proto native int ObjectRelease(Object obj);
  proto void ObjectGetType(Object obj, out string type);
  proto void ObjectGetDisplayName(Object obj, out string name);
  proto native vector ObjectGetSelectionPosition(Object obj, string name);
  proto native vector ObjectGetSelectionPositionLS(Object obj, string name);
  proto native vector ObjectGetSelectionPositionMS(Object obj, string name);
  proto native vector ObjectGetSelectionPositionWS(Object obj, string name);
  proto native vector ObjectModelToWorld(Object obj, vector modelPos);
  proto native vector ObjectWorldToModel(Object obj, vector worldPos);
  proto native bool IsObjectAccesible(EntityAI item, Man player);
 
  // input
  proto native Input GetInput();
 
  // camera
  proto native vector GetCurrentCameraPosition();
  proto native vector GetCurrentCameraDirection();
 
  // sound
  proto native AbstractSoundScene GetSoundScene();
 
  // noise
  proto native NoiseSystem GetNoiseSystem();
 
  // inventory
  proto native bool AddInventoryJuncture(Man player, notnull EntityAI item, InventoryLocation dst, bool test_dst_occupancy, int timeout_ms);
 
  bool AddInventoryJunctureEx(Man player, notnull EntityAI item, InventoryLocation dst, bool test_dst_occupancy, int timeout_ms)
  {
    bool result = AddInventoryJuncture(player, item, dst, test_dst_occupancy, timeout_ms/*10000000*/);
#ifdef DEVELOPER
    if (LogManager.IsInventoryReservationLogEnable())
      Debug.InventoryReservationLog("STS = " + player.GetSimulationTimeStamp() + " result: " + result + " item:" + item + " dst: " + InventoryLocation.DumpToStringNullSafe(dst), "n/a", "n/a", "AddInventoryJuncture", player.ToString());
#endif
    //Print("Juncture - STS = " + player.GetSimulationTimeStamp() + " item:" + item + " dst: " + InventoryLocation.DumpToStringNullSafe(dst));
    return result;
  }
 
  //Has inventory juncture for any player
  proto native bool HasInventoryJunctureItem(notnull EntityAI item);
 
  proto native bool HasInventoryJunctureDestination(Man player, notnull InventoryLocation dst);
  proto native bool AddActionJuncture(Man player, notnull EntityAI item, int timeout_ms);
  proto native bool ExtendActionJuncture(Man player, notnull EntityAI item, int timeout_ms);
  proto native bool ClearJuncture(Man player, notnull EntityAI item);
 
  bool ClearJunctureEx(Man player, notnull EntityAI item)
  {
#ifdef DEVELOPER
    if (LogManager.IsInventoryReservationLogEnable())
      Debug.InventoryReservationLog("STS = " + player.GetSimulationTimeStamp() + " item:" + item, "n/a", "n/a", "ClearJuncture", player.ToString());
#endif
    return ClearJuncture(player, item);
  }
 
  // support
  proto native bool ExecuteEnforceScript(string expression, string mainFnName);
  proto native void DumpInstances(bool csvFormatting);
 
  proto native bool ScriptTest();
  proto native void GetDiagModeNames(out TStringArray diag_names);
  proto native void SetDiagModeEnable(int diag_mode, bool enabled);
  proto native bool GetDiagModeEnable(int diag_mode);
 
  proto native void GetDiagDrawModeNames(out TStringArray diag_names);
  proto native void SetDiagDrawMode(int diag_draw_mode);
  proto native int GetDiagDrawMode();
 
  proto native bool IsPhysicsExtrapolationEnabled();
 
  proto native float GetFps();
 
  proto native float GetTickTime();
 
  proto void GetInventoryItemSize(InventoryItem item, out int width, out int height);
  proto native void GetObjectsAtPosition(vector pos, float radius, out array<Object> objects, out array<CargoBase> proxyCargos);
  proto native void GetObjectsAtPosition3D(vector pos, float radius, out array<Object> objects, out array<CargoBase> proxyCargos);
  proto native World GetWorld();
  proto void GetWorldName(out string world_name);
 
  string GetWorldName()
  {
    string world_name;
    g_Game.GetWorldName(world_name);
    return world_name;
  }
 
  proto native bool VerifyWorldOwnership(string sWorldName);
  proto native bool GoBuyWorldDLC(string sWorldName);
 
  proto void FormatString(string format, string params[], out string output);
  proto void GetVersion(out string version);
  proto native UIManager GetUIManager();
  proto native DayZPlayer GetPlayer();
  proto native void GetPlayers(out array<Man> players);
  DayZPlayer GetPlayerByIndex(int index = 0)
  {
    array<Man> players();
    GetPlayers(players);
    if (index >= players.Count())
      return null;
    return DayZPlayer.Cast(players[index]);
  }
 
  proto native void StoreLoginData(ParamsWriteContext ctx);
 
  proto native vector GetPointerDirection();
  proto native vector GetWorldDirectionFromScreen(vector world_pos);
  proto native vector GetScreenPos(vector world_pos);
  proto native vector GetScreenPosRelative(vector world_pos);
 
  proto native MenuData GetMenuData();
  proto native void RPC(Object target, int rpcType, notnull array<ref Param> params, bool guaranteed, PlayerIdentity recipient = null);
  void RPCSingleParam(Object target, int rpc_type, Param param, bool guaranteed, PlayerIdentity recipient = null)
  {
    m_ParamCache.Set(0, param);
    RPC(target, rpc_type, m_ParamCache, guaranteed, recipient);
  }
  proto native void RPCSelf(Object target, int rpcType, notnull array<ref Param> params);
  void RPCSelfSingleParam(Object target, int rpcType, Param param)
  {
    m_ParamCache.Set(0, param);
    RPCSelf(target, rpcType, m_ParamCache);
  }
 
  proto native void ProfilerStart(string name);
  proto native void ProfilerStop(string name);
 
 
  proto native void Chat(string text, string colorClass);
  proto native void ChatMP(Man recipient, string text, string colorClass);
  proto native void ChatPlayer(string text);
  proto native void MutePlayer(string muteUID, string playerUID, bool mute);
 
  proto native void MuteAllPlayers(string listenerId, bool mute);
 
  proto native void EnableVoN(Object player, bool enable);
 
  proto native void SetVoiceEffect(Object player, int effect, bool enable);
 
  proto native void SetVoiceLevel(int level);
 
  proto native int GetVoiceLevel(Object player = null);
 
  proto native void EnableMicCapture(bool enable);
 
  proto native bool IsMicCapturing();
 
  proto native bool IsInPartyChat();
 
  // mission
  proto native Mission GetMission();
  proto native void SetMission(Mission mission);
 
 
  proto native void StartRandomCutscene(string world);
  proto native void PlayMission(string path);
 
  proto protected native void CreateMission(string path);
  proto native void RestartMission();
  proto native void AbortMission();
  proto native void RespawnPlayer();
  proto native bool CanRespawnPlayer();
  proto native void SetLoginTimerFinished();
 
  proto native void SetMainMenuWorld(string world);
  proto native owned string GetMainMenuWorld();
 
  proto native void LogoutRequestTime();
  proto native void LogoutRequestCancel();
 
  proto native bool IsMultiplayer();
  proto native bool IsClient();
  proto native bool IsServer();
  proto native bool IsDedicatedServer();
 
  proto native int ServerConfigGetInt(string name);
 
  // Internal build
  proto native bool IsDebug();
 
  //#ifdef PLATFORM_XBOX
  static bool IsDigitalCopy()
  {
    return OnlineServices.IsGameActive(false);
  }
  //#endif
 
  /*bool IsNewMenu()
    {
    return m_ParamNewMenu;
    }*/
 
  void SetDebugMonitorEnabled(int value)
  {
    m_DebugMonitorEnabled = value;
  }
 
  bool IsDebugMonitor()
  {
    return IsServer() && m_DebugMonitorEnabled;
  }
 
  proto native void GetPlayerIndentities(out array<PlayerIdentity> identities);
 
  proto native float SurfaceY(float x, float z);
  proto native float SurfaceRoadY(float x, float z, RoadSurfaceDetection rsd = RoadSurfaceDetection.LEGACY);
  proto native float SurfaceRoadY3D(float x, float y, float z, RoadSurfaceDetection rsd);
  proto void SurfaceGetType(float x, float z, out string type);
  proto void SurfaceGetType3D(float x, float y, float z, out string type);
  proto void SurfaceUnderObject(notnull Object object, out string type, out int liquidType);
  proto void SurfaceUnderObjectEx(notnull Object object, out string type, out string impact, out int liquidType);
  proto void SurfaceUnderObjectByBone(notnull Object object, int boneType, out string type, out int liquidType);
  proto native float SurfaceGetNoiseMultiplier(Object directHit, vector pos, int componentIndex);
  proto native vector SurfaceGetNormal(float x, float z);
  proto native float SurfaceGetSeaLevel();
  proto native bool SurfaceIsSea(float x, float z);
  proto native bool SurfaceIsPond(float x, float z);
  proto native float GetWaterDepth(vector posWS);
 
  proto native void UpdatePathgraphRegion(vector regionMin, vector regionMax);
 
  float GetHighestSurfaceYDifference(array<vector> positions)
  {
    float high = -9999999;
    float low = 99999999;
 
    for (int i = 0; i < positions.Count(); i++)
    {
      vector pos = positions.Get(i);
      pos[1] = SurfaceRoadY(pos[0], pos[2]);
      float y = pos[1];
 
      if (y > high)
        high = y;
 
      if (y < low)
        low = y;
 
      ;
    }
 
    return high - low;
  }
 
  vector GetSurfaceOrientation(float x, float z)
  {
    vector normal = GetGame().SurfaceGetNormal(x, z);
    vector angles = normal.VectorToAngles();
    angles[1] = angles[1] + 270; // This fixes rotation of item so it stands vertically. Feel free to change, but fix existing use cases.
 
    //Hack because setorientation and similar functions break and flip stuff upside down when using exactly this vector ¯\_(ツ)_/¯ (note: happens when surface is flat)
    if (angles == "0 540 0")
      angles = "0 0 0";
    return angles;
  }
 
  bool IsSurfaceDigable(string surface)
  {
    return ConfigGetInt("CfgSurfaces " + surface + " isDigable");
  }
 
  bool IsSurfaceFertile(string surface)
  {
    return ConfigGetInt("CfgSurfaces " + surface + " isFertile");
  }
 
  void UpdatePathgraphRegionByObject(Object object)
  {
    if (object)
    {
      vector pos = object.GetPosition();
      vector min_max[2];
      float radius = object.ClippingInfo(min_max);
      vector min = Vector(pos[0] - radius, pos[1], pos[2] - radius);
      vector max = Vector(pos[0] + radius, pos[1], pos[2] + radius);
      UpdatePathgraphRegion(min, max);
    }
  }
 
  proto native bool IsBoxColliding(vector center, vector orientation, vector edgeLength, array<Object> excludeObjects, array<Object> collidedObjects = NULL);
 
  proto native bool IsBoxCollidingGeometry(vector center, vector orientation, vector edgeLength, int iPrimaryType, int iSecondaryType, array<Object> excludeObjects, array<Object> collidedObjects = NULL);
 
  proto native bool IsBoxCollidingGeometryProxy(notnull BoxCollidingParams params, array<Object> excludeObjects, array<ref BoxCollidingResult> collidedObjects = NULL);
 
  proto native Weather GetWeather();
 
  proto native void SetEVUser(float value);
 
  proto native void OverrideDOF(bool enable, float focusDistance, float focusLength, float focusLengthNear, float blur, float focusDepthOffset);
 
  proto native void AddPPMask(float ndcX, float ndcY, float ndcRadius, float ndcBlur);
 
  proto native void ResetPPMask();
 
  proto native void OverrideInventoryLights(vector diffuse, vector ambient, vector ground, vector dir);
 
  proto native void NightVissionLightParams(float lightIntensityMul, float noiseIntensity);
 
 
  proto native void OpenURL(string url);
 
  proto native void InitDamageEffects(Object effect);
 
  //-----------------------------------------------------------------------------
  // persitence
  //-----------------------------------------------------------------------------
 
 
  proto native EntityAI GetEntityByPersitentID(int b1, int b2, int b3, int b4);
 
  //-----------------------------------------------------------------------------
 
  bool IsKindOf(string cfg_class_name, string cfg_parent_name)
  {
    TStringArray full_path = new TStringArray;
 
    ConfigGetFullPath("CfgVehicles " + cfg_class_name, full_path);
 
    if (full_path.Count() == 0)
      ConfigGetFullPath("CfgAmmo " + cfg_class_name, full_path);
 
    if (full_path.Count() == 0)
      ConfigGetFullPath("CfgMagazines " + cfg_class_name, full_path);
 
    if (full_path.Count() == 0)
      ConfigGetFullPath("cfgWeapons " + cfg_class_name, full_path);
 
    if (full_path.Count() == 0)
      ConfigGetFullPath("CfgNonAIVehicles " + cfg_class_name, full_path);
 
    cfg_parent_name.ToLower();
    for (int i = 0; i < full_path.Count(); i++)
    {
      string tmp = full_path.Get(i);
      tmp.ToLower();
      if (tmp == cfg_parent_name)
        return true;
    }
 
    return false;
  }
 
  bool ObjectIsKindOf(Object object, string cfg_parent_name)
  {
    TStringArray full_path = new TStringArray;
    ConfigGetObjectFullPath(object, full_path);
 
    cfg_parent_name.ToLower();
 
    for (int i = 0; i < full_path.Count(); i++)
    {
      string tmp = full_path.Get(i);
      tmp.ToLower();
      if (tmp == cfg_parent_name)
        return true;
    }
 
    return false;
  }
 
  int ConfigFindClassIndex(string config_path, string searched_member)
  {
    int class_count = ConfigGetChildrenCount(config_path);
    for (int index = 0; index < class_count; index++)
    {
      string found_class = "";
      ConfigGetChildName(config_path, index, found_class);
      if (found_class == searched_member)
        return index;
    }
    return -1;
  }
 
  proto int GetTime();
 
  ScriptCallQueue GetCallQueue(int call_category) {}
 
  ScriptInvoker GetUpdateQueue(int call_category) {}
 
  ScriptInvoker GetPostUpdateQueue(int call_category) {}
  TimerQueue GetTimerQueue(int call_category) {}
 
  DragQueue GetDragQueue() {}
 
  string CreateDefaultPlayer() {}
 
  string CreateRandomPlayer() {}
 
  TStringArray ListAvailableCharacters() {}
 
  bool IsInventoryOpen()
  {
  }
 
  proto native BiosUserManager GetUserManager();
 
  proto native ContentDLC GetContentDLCService();
 
  bool IsMissionMainMenu()
  {
    return (g_Game.GetMissionState() == DayZGame.MISSION_STATE_MAINMENU);
  }
 
  MenuDefaultCharacterData GetMenuDefaultCharacterData(bool fill_data = true)
  {
    //Print("GetMenuDefaultCharacterData");
    //DumpStack();
    //if used on server, creates an empty container to be filled by received data
    if (!m_CharacterData)
    {
      m_CharacterData = new MenuDefaultCharacterData;
      if (fill_data)
        GetGame().GetMenuData().RequestGetDefaultCharacterData(); //fills the structure
    }
    return m_CharacterData;
  }
 
  //Analytics Manager
  AnalyticsManagerServer GetAnalyticsServer()
  {
    return m_AnalyticsManagerServer;
  }
 
  AnalyticsManagerClient GetAnalyticsClient()
  {
    return m_AnalyticsManagerClient;
  }
};