CfgGameplayHandler.c

Go to the documentation of this file.

class CfgGameplayHandler
{
  private static string m_Path = "$mission:cfggameplay.json";
  private static ref array<ref ITEM_DataBase> m_Items = new array<ref ITEM_DataBase>();
 
  static ref CfgGameplayJson m_Data = new CfgGameplayJson();
 
  //---------------------------------------------------------------------------------------
  static void RegisterItem(ITEM_DataBase item)
  {
    m_Items.Insert(item);
  }
  //---------------------------------------------------------------------------------------
  private static void ValidateItems()
  {
    foreach (ITEM_DataBase item : m_Items)
    {
      if (!item.ValidateServer())
      {
        string itemName = item.Type().ToString();
        itemName.Replace("ITEM_", "");
        PrintToRPT("Validation failed during loading of 'cfggameplay.json' for " + itemName);
        item.InitServer();
      }
    }
  }
 
  //---------------------------------------------------------------------------------------
  private static void InitData()
  {
    foreach (ITEM_DataBase item: m_Items)
      item.InitServer();
  }
#ifdef DEVELOPER
  //---------------------------------------------------------------------------------------
  static void Output()
  {
    Print(m_Items.Count());
  }
#endif
  //---------------------------------------------------------------------------------------
  static bool LoadData()
  {
    if (!FileExist(m_Path))
    {
      m_Path = "";
      GetGame().GetWorldName(m_Path);
      m_Path = string.Format("dz/worlds/%1/ce/cfggameplay.json", m_Path);
    }
 
    bool cfgGameplayFileEnabled = GetGame().ServerConfigGetInt("enableCfgGameplayFile");
 
#ifdef DIAG_DEVELOPER
    if (!GetGame().IsDedicatedServer())
      cfgGameplayFileEnabled = true;
#endif
 
    if (!cfgGameplayFileEnabled || !FileExist(m_Path))
    {
      m_Data.InitServer();//legacy call
      InitData();
      OnLoaded();
      return false;
    }
 
    string errorMessage;
    if (!JsonFileLoader<CfgGameplayJson>.LoadFile(m_Path, m_Data, errorMessage)) 
      ErrorEx(errorMessage);
 
    ValidateItems();
    OnLoaded();
 
    return true;
  }
 
  //---------------------------------------------------------------------------------------
  static void OnLoaded()
  {
    GetGame().GetMission().OnGameplayDataHandlerLoad();
    DayZGame.Cast(GetGame()).OnGameplayDataHandlerLoad();
  }
 
  //---------------------------------------------------------------------------------------
  static void SyncDataSend(notnull Man player)
  {
    GetGame().RPCSingleParam(player, ERPCs.RPC_CFG_GAMEPLAY_SYNC, new Param1<CfgGameplayJson>(m_Data), true, player.GetIdentity());
  }
 
  //---------------------------------------------------------------------------------------
  static void SyncDataSendEx(notnull PlayerIdentity identity)
  {
    //Debug.Log("SyncDataSendEx");
    GetGame().RPCSingleParam(null, ERPCs.RPC_CFG_GAMEPLAY_SYNC, new Param1<CfgGameplayJson>(m_Data), true, identity);
  }
 
  //---------------------------------------------------------------------------------------
 
  static void OnRPC(Man player, ParamsReadContext ctx)
  {
    Param1<CfgGameplayJson> data = new Param1<CfgGameplayJson>(null);
 
    if (ctx.Read(data))
      m_Data = data.param1;
    else
      ErrorEx("CfgGameplayHandler - client failed to read incoming data");
  }
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
  //========================
  // !!! ONLY GETTERS BELLOW
  //========================
 
 
  //----------------------------------------------------------------------------------
  static bool GetDisablePersonalLight()
  {
    return m_Data.PlayerData.disablePersonalLight;
  }
  //----------------------------------------------------------------------------------
 
  //-------------------------------   WorldsData   -----------------------------------
  static int GetLightingConfig()
  {
    return m_Data.WorldsData.lightingConfig;
  }
 
  static TStringArray GetObjectSpawnersArr()
  {
    return m_Data.WorldsData.objectSpawnersArr;
  }
 
  static array<float> GetEnvironmentMinTemps()
  {
    return m_Data.WorldsData.environmentMinTemps;
  }
 
  static array<float> GetEnvironmentMaxTemps()
  {
    return m_Data.WorldsData.environmentMaxTemps;
  }
  static array<float> GetWetnessWeightModifiers()
  {
    return m_Data.WorldsData.wetnessWeightModifiers;
  }
  //----------------------------------------------------------------------------------
 
 
  static bool GetDisableBaseDamage()
  {
    return m_Data.GeneralData.disableBaseDamage;
  }
  //----------------------------------------------------------------------------------
 
  static bool GetDisableContainerDamage()
  {
    return m_Data.GeneralData.disableContainerDamage;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableRespawnDialog()
  {
    return m_Data.GeneralData.disableRespawnDialog;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableRespawnInUnconsciousness()
  {
    return m_Data.GeneralData.disableRespawnInUnconsciousness;
  }
  //----------------------------------------------------------------------------------
  static float GetSprintStaminaModifierErc()
  {
    return m_Data.PlayerData.StaminaData.sprintStaminaModifierErc;
  }
  //----------------------------------------------------------------------------------
  static float GetSprintStaminaModifierCro()
  {
    return m_Data.PlayerData.StaminaData.sprintStaminaModifierCro;
  }
  //----------------------------------------------------------------------------------
  static float GetSprintSwimmingStaminaModifier()
  {
    return m_Data.PlayerData.StaminaData.sprintSwimmingStaminaModifier;
  }//----------------------------------------------------------------------------------
  static float GetSprintLadderStaminaModifier()
  {
    return m_Data.PlayerData.StaminaData.sprintLadderStaminaModifier;
  }
  //----------------------------------------------------------------------------------
  static float GetStaminaWeightLimitThreshold()
  {
    return m_Data.PlayerData.StaminaData.staminaWeightLimitThreshold;
  }
  //----------------------------------------------------------------------------------
  static float GetStaminaMax()
  {
    return m_Data.PlayerData.StaminaData.staminaMax;
  }
  //----------------------------------------------------------------------------------
  static float GetStaminaKgToStaminaPercentPenalty()
  {
    return m_Data.PlayerData.StaminaData.staminaKgToStaminaPercentPenalty;
  }
  //----------------------------------------------------------------------------------
  static float GetStaminaMinCap()
  {
    return m_Data.PlayerData.StaminaData.staminaMinCap;
  }
  //----------------------------------------------------------------------------------
  static float GetMeleeStaminaModifier()
  {
    return m_Data.PlayerData.StaminaData.meleeStaminaModifier;
  }
  //----------------------------------------------------------------------------------
  static float GetObstacleTraversalStaminaModifier()
  {
    return m_Data.PlayerData.StaminaData.obstacleTraversalStaminaModifier;
  }
  //----------------------------------------------------------------------------------
  static float GetHoldBreathStaminaModifier()
  {
    return m_Data.PlayerData.StaminaData.holdBreathStaminaModifier;
  }
  //----------------------------------------------------------------------------------
  static float GetMovementTimeToStrafeJog()
  {
    return Math.Max(0.01, m_Data.PlayerData.MovementData.timeToStrafeJog);
  }
  //----------------------------------------------------------------------------------
  static float GetMovementTimeToSprint()
  {
    return Math.Max(0.01, m_Data.PlayerData.MovementData.timeToSprint);
  }
  //----------------------------------------------------------------------------------
  static float GetMovementTimeToStrafeSprint()
  {
    return Math.Max(0.01, m_Data.PlayerData.MovementData.timeToStrafeSprint);
  }
  //----------------------------------------------------------------------------------
  static float GetMovementRotationSpeedJog()
  {
    return Math.Max(0.01, m_Data.PlayerData.MovementData.rotationSpeedJog);
  }
  //----------------------------------------------------------------------------------
  static float GetMovementRotationSpeedSprint()
  {
    return Math.Max(0.01, m_Data.PlayerData.MovementData.rotationSpeedSprint);
  }
  //----------------------------------------------------------------------------------
  static bool GetDisable2dMap()
  {
    return m_Data.PlayerData.disable2dMap;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableIsCollidingBBoxCheck()
  {
    return m_Data.BaseBuildingData.HologramData.disableIsCollidingBBoxCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableIsCollidingPlayerCheck()
  {
    return m_Data.BaseBuildingData.HologramData.disableIsCollidingPlayerCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableIsClippingRoofCheck()
  {
    return m_Data.BaseBuildingData.HologramData.disableIsClippingRoofCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableIsBaseViableCheck()
  {
    return m_Data.BaseBuildingData.HologramData.disableIsBaseViableCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableIsInTerrainCheck()
  {
    return m_Data.BaseBuildingData.HologramData.disableIsInTerrainCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableIsUnderwaterCheck()
  {
    return m_Data.BaseBuildingData.HologramData.disableIsUnderwaterCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableHeightPlacementCheck()
  {
    return m_Data.BaseBuildingData.HologramData.disableHeightPlacementCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableIsPlacementPermittedCheck()
  {
    return m_Data.BaseBuildingData.HologramData.disableIsPlacementPermittedCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableIsCollidingAngleCheck()
  {
    return m_Data.BaseBuildingData.HologramData.disableIsCollidingAngleCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableIsCollidingGPlotCheck()
  {
    return m_Data.BaseBuildingData.HologramData.disableIsCollidingGPlotCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableIsCollidingCheck()
  {
    return m_Data.BaseBuildingData.ConstructionData.disableIsCollidingCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisablePerformRoofCheck()
  {
    return m_Data.BaseBuildingData.ConstructionData.disablePerformRoofCheck;
  }
  //----------------------------------------------------------------------------------
  static bool GetDisableDistanceCheck()
  {
    return m_Data.BaseBuildingData.ConstructionData.disableDistanceCheck;
  }
  //----------------------------------------------------------------------------------
  static TStringSet GetDisallowedTypesInUnderground()
  {
    return m_Data.BaseBuildingData.HologramData.disallowedTypesInUnderground;
  }
  //----------------------------------------------------------------------------------
  static bool GetHitIndicationOverrideEnabled() //TODO - ?
  {
    return m_Data.UIData.HitIndicationData.hitDirectionOverrideEnabled;
  }
  //----------------------------------------------------------------------------------
  static int GetHitIndicationMode()
  {
    return m_Data.UIData.HitIndicationData.hitDirectionBehaviour;
  }
  //----------------------------------------------------------------------------------
  static int GetHitIndicationTypeID()
  {
    return m_Data.UIData.HitIndicationData.hitDirectionStyle;
  }
  //----------------------------------------------------------------------------------
  static int GetHitIndicationIndicatorColor()
  {
    return m_Data.UIData.HitIndicationData.hitDirectionIndicatorColorStr.HexToInt();
  }
  //----------------------------------------------------------------------------------
  static float GetHitIndicationMaxDuration()
  {
    return m_Data.UIData.HitIndicationData.hitDirectionMaxDuration;
  }
  //----------------------------------------------------------------------------------
  static float GetHitIndicationBreakPoint()
  {
    return m_Data.UIData.HitIndicationData.hitDirectionBreakPointRelative;
  }
  //----------------------------------------------------------------------------------
  static float GetHitIndicationScatter()
  {
    return m_Data.UIData.HitIndicationData.hitDirectionScatter;
  }
  //----------------------------------------------------------------------------------
  static bool GetHitIndicationPPEEnabled()
  {
    return m_Data.UIData.HitIndicationData.hitIndicationPostProcessEnabled;
  }
  //----------------------------------------------------------------------------------
  static bool GetUse3DMap()
  {
    return m_Data.UIData.use3DMap;
  }
  //----------------------------------------------------------------------------------
  static float GetShockRefillSpeedConscious()
  {
    return m_Data.PlayerData.ShockHandlingData.shockRefillSpeedConscious;
  }
  //----------------------------------------------------------------------------------
  static float GetShockRefillSpeedUnconscious()
  {
    return m_Data.PlayerData.ShockHandlingData.shockRefillSpeedUnconscious;
  }
  //----------------------------------------------------------------------------------
  static bool GetAllowRefillSpeedModifier()
  {
    return m_Data.PlayerData.ShockHandlingData.allowRefillSpeedModifier;
  }
 
  //--- MapData ----------------------------------------------------------------------
  static bool GetMapIgnoreMapOwnership()
  {
    return m_Data.MapData.ignoreMapOwnership;
  }
  //----------------------------------------------------------------------------------
  static bool GetMapIgnoreNavItemsOwnership()
  {
    return m_Data.MapData.ignoreNavItemsOwnership;
  }
  //----------------------------------------------------------------------------------
  static bool GetMapDisplayPlayerPosition()
  {
    return m_Data.MapData.displayPlayerPosition;
  }
  //----------------------------------------------------------------------------------
  static bool GetMapDisplayNavigationInfo()
  {
    return m_Data.MapData.displayNavInfo;
  }
  //----------------------------------------------------------------------------------
  static float GetStaminaDepletionSpeed()
  {
    return m_Data.PlayerData.DrowningData.staminaDepletionSpeed;
  }
  //----------------------------------------------------------------------------------
  static float GetHealthDepletionSpeed()
  {
    return m_Data.PlayerData.DrowningData.healthDepletionSpeed;
  }
  //----------------------------------------------------------------------------------
  static float GetShockDepletionSpeed()
  {
    return m_Data.PlayerData.DrowningData.shockDepletionSpeed;
  }
  //----------------------------------------------------------------------------------
  static bool GetAllowStaminaAffectInertia()
  {
    return m_Data.PlayerData.MovementData.allowStaminaAffectInertia;
  }
  //----------------------------------------------------------------------------------
  static TStringArray GetPlayerSpawnGearPresetFiles()
  {
    return m_Data.PlayerData.spawnGearPresetFiles;
  }
  //----------------------------------------------------------------------------------
}