gameplay.c

Go to the documentation of this file.

 
enum InventoryTraversalType
{
  PREORDER,
  INORDER,
  POSTORDER,
  LEVELORDER
};
 
const int INDEX_NOT_FOUND = -1;
//-----------------------------------------------------------------------------
typedef Serializer ParamsReadContext;
typedef Serializer ParamsWriteContext;
 
class JsonSerializer: Serializer
{
  void JsonSerializer() {}
  void ~JsonSerializer() {}
 
  proto bool WriteToString(void variable_out, bool nice, out string result);
 
  proto bool ReadFromString(void variable_in, string jsonString, out string error);
};
 
 
class ScriptRPC: ParamsWriteContext
{
  void ScriptRPC();
  void ~ScriptRPC();
  proto native void Reset();
  proto native void Send(Object target, int rpc_type, bool guaranteed, PlayerIdentity recipient = NULL);
};
 
class ScriptInputUserData : ParamsWriteContext
{
  void ScriptInputUserData();
  void ~ScriptInputUserData();
 
  proto native void Reset();
  proto native void Send();
 
  proto native bool CopyFrom(ParamsReadContext other);
 
  proto native static bool CanStoreInputUserData();
};
 
class ScriptReadWriteContext
{
  void ScriptReadWriteContext();
  void ~ScriptReadWriteContext();
 
  proto native ParamsWriteContext GetWriteContext();
  proto native ParamsReadContext GetReadContext();
};
 
class ScriptRemoteInputUserData : ParamsWriteContext
{
  void ScriptRemoteInputUserData();
  void ~ScriptRemoteInputUserData();
 
  proto native void Reset();
};
 
class ScriptJunctureData : ParamsWriteContext
{
  void ScriptJunctureData();
  void ~ScriptJunctureData();
 
  proto native void Reset();
};
 
//-----------------------------------------------------------------------------
class MeleeCombatData
{
  proto native int GetModesCount();
 
  proto native owned string GetModeName(int index);
 
  proto native owned string GetAmmoTypeName(int index);
 
  proto native float GetModeRange(int index);
 
  private void MeleeCombatData();
  private void ~MeleeCombatData();
}
 
//-----------------------------------------------------------------------------
const string NullStringArray[1] = { "" };
 
//-----------------------------------------------------------------------------
class Selection
{
  private void Selection() {}
  private void ~Selection() {}
 
  proto native owned string GetName();
  proto native int GetVertexCount();
  proto native int GetLODVertexIndex(int sel_vertex_index);
 
  vector GetVertexPosition(LOD lod, int index)
  {
    int lodIndex = GetLODVertexIndex(index);
    if (lodIndex == -1)
    {
      Error("Vertex doesn't exist");
      return vector.Zero;
    }
 
    return lod.GetVertexPosition(lodIndex);
  }
};
 
//-----------------------------------------------------------------------------
class LOD
{
  // standard(BI) LOD names in p3d
  static const string NAME_GEOMETRY = "geometry";
  static const string NAME_VIEW = "view";
  static const string NAME_FIRE = "fire";
  static const string NAME_MEMORY = "memory";
  static const string NAME_ROADWAY = "roadway";
 
  private void LOD() {}
  private void ~LOD() {}
 
  proto native int GetSelectionCount();
  proto native bool GetSelections(notnull out array<Selection> selections);
 
  proto native vector GetVertexPosition(int vertex_index);
 
  proto native owned string GetName(Object myObject);
 
  Selection GetSelectionByName(string name)
  {
    array<Selection> selections = new array<Selection>;
    GetSelections(selections);
 
    for (int i = 0; i < selections.Count(); ++i)
    {
      string selection_name = selections.Get(i).GetName();
      selection_name.ToLower();
      name.ToLower();
      if (selection_name == name)
        return selections.Get(i);
    }
 
    return null;
  }
 
  proto native int GetPropertyCount();
  proto native owned string GetPropertyName(int index);
  proto native owned string GetPropertyValue(int index);
}
 
class Plant extends Object
{
};
 
/*
  class ParamEntry
  {
  proto string GetString(string entryName);
  proto int GetInt(string entryName);
  proto float GetFloat(string entryName);
  proto ref ParamEntry GetEntry(string entryName);
  proto int GetNumChildren();
  proto ref ParamEntry GetNumChildren(int n);
  };
*/
//-----------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------
class ProxyInventory extends ObjectTyped
{
};
 
//-----------------------------------------------------------------------------
class ProxySubpart extends Entity
{
};
 
//-----------------------------------------------------------------------------
// custom widgets
//-----------------------------------------------------------------------------
class ItemPreviewWidget: Widget
{
  proto native void SetItem(EntityAI object);
  proto native EntityAI GetItem();
 
  proto native int GetView();
  proto native void SetView(int viewIndex);
 
  proto native void SetModelOrientation(vector vOrientation);
  proto native vector GetModelOrientation();
  proto native void SetModelPosition(vector vPos);
  proto native vector GetModelPosition();
 
  proto native void SetForceFlipEnable(bool enable);
  proto native void SetForceFlip(bool value);
};
 
//-----------------------------------------------------------------------------
class PlayerPreviewWidget: Widget
{
  proto native void UpdateItemInHands(EntityAI object);
  proto native void SetPlayer(DayZPlayer player);
  //proto native void   SetPlayerType(string type);
  proto native DayZPlayer GetDummyPlayer();
 
  proto native void Refresh();
 
  proto native void SetModelOrientation(vector vOrientation);
  proto native vector GetModelOrientation();
  proto native void SetModelPosition(vector vPos);
  proto native vector GetModelPosition();
};
 
//-----------------------------------------------------------------------------
class HtmlWidget extends RichTextWidget
{
  proto native void LoadFile(string path);
};
 
//-----------------------------------------------------------------------------
class MapWidget: Widget
{
  proto native void ClearUserMarks();
  proto native void AddUserMark(vector pos, string text, int color /*ARGB*/, string texturePath);
  proto native vector GetMapPos();
  proto native void SetMapPos(vector worldPos);
  proto native float GetScale();
  proto native void SetScale(float scale);
  proto native float GetContourInterval();
  proto native float GetCellSize(float pLegendWidth);
  proto native vector MapToScreen(vector worldPos);
  proto native vector ScreenToMap(vector screenPos);
};
 
//-----------------------------------------------------------------------------
class PlayerIdentityBase : Managed
{
  proto int GetPingAct();
  proto int GetPingMin();
  proto int GetPingMax();
  proto int GetPingAvg();
 
  proto int GetBandwidthMin();
  proto int GetBandwidthMax();
  proto int GetBandwidthAvg();
 
  proto string GetName();
  proto string GetPlainName();
  proto string GetFullName();
  proto string GetId();
  proto string GetPlainId();
  proto int GetPlayerId();
 
  proto Man GetPlayer();
 
  private void PlayerIdentityBase();
  private void ~PlayerIdentityBase();
};
 
class PlayerIdentity : PlayerIdentityBase
{
 
}
 
//-----------------------------------------------------------------------------
const int PROGRESS_START = 0;
const int PROGRESS_FINISH = 1;
const int PROGRESS_PROGRESS = 2;
const int PROGRESS_UPDATE = 3;
 
//-----------------------------------------------------------------------------
typedef int ChatChannel;
 
//-----------------------------------------------------------------------------
typedef Param3<int, float, string> ProgressEventParams;
typedef Param1<string> ScriptLogEventParams;
typedef Param4<int, string, string, string> ChatMessageEventParams;
typedef Param1<int> ChatChannelEventParams;
typedef Param1<int> SQFConsoleEventParams;
 
typedef Param2<string, string> ClientConnectedEventParams;
typedef Param5<PlayerIdentity, bool, vector, float, int> ClientPrepareEventParams;
typedef Param3<PlayerIdentity, vector, Serializer> ClientNewEventParams;
typedef Param2<PlayerIdentity, Man> ClientNewReadyEventParams;
typedef Param2<PlayerIdentity, Man> ClientRespawnEventParams;
typedef Param2<PlayerIdentity, Man> ClientReadyEventParams;
typedef Param2<PlayerIdentity, Man> ClientReconnectEventParams;
typedef Param4<PlayerIdentity, Man, int, bool> ClientDisconnectedEventParams;
 
typedef Param1<int> LoginTimeEventParams;
typedef Param1<int> RespawnEventParams;
typedef Param1<vector> PreloadEventParams;
typedef Param1<Man> LogoutCancelEventParams;
typedef Param1<PlayerIdentity> ConnectivityStatsUpdatedEventParams;
typedef Param1<float> ServerFpsStatsUpdatedEventParams;
typedef Param2<string, string> LoginStatusEventParams;
typedef Param1<int> LogoutEventParams;
typedef Param3<int, int, bool> WindowsResizeEventParams;
typedef Param2<bool, bool> VONStateEventParams;
typedef Param2<string, string> VONStartSpeakingEventParams;
typedef Param2<string, string> VONStopSpeakingEventParams;
typedef Param1<string> DLCOwnerShipFailedParams;
typedef Param1<FreeDebugCamera> SetFreeCameraEventParams;
typedef Param1<int> MPConnectionLostEventParams;
typedef Param2<int, string> MPConnectionCloseEventParams;
typedef Param2<DayZPlayer, Object> PlayerDeathEventParams;
 
 
//-----------------------------------------------------------------------------
 
const EventType StartupEventTypeID;
const EventType WorldCleaupEventTypeID;
 
//-----------------------------------------------------------------------------
const EventType MPSessionStartEventTypeID;
const EventType MPSessionEndEventTypeID;
const EventType MPSessionFailEventTypeID;
const EventType MPSessionPlayerReadyEventTypeID;
const EventType MPConnectionLostEventTypeID;
const EventType MPConnectionCloseEventTypeID;
 
//-----------------------------------------------------------------------------
const EventType ProgressEventTypeID;
const EventType NetworkManagerClientEventTypeID;
const EventType NetworkManagerServerEventTypeID;
const EventType DialogQueuedEventTypeID;
 
//-----------------------------------------------------------------------------
const EventType ChatMessageEventTypeID;
const EventType ChatChannelEventTypeID;
 
//-----------------------------------------------------------------------------
const EventType ClientConnectedEventTypeID;
const EventType ClientPrepareEventTypeID;
const EventType ClientNewEventTypeID;
const EventType ClientNewReadyEventTypeID;
const EventType ClientRespawnEventTypeID;
const EventType ClientReconnectEventTypeID;
const EventType ClientReadyEventTypeID;
const EventType ClientDisconnectedEventTypeID;
const EventType ClientRemovedEventTypeID;
 
//-----------------------------------------------------------------------------
const EventType ConnectivityStatsUpdatedEventTypeID;
const EventType ServerFpsStatsUpdatedEventTypeID;
const EventType LogoutCancelEventTypeID;
const EventType LoginTimeEventTypeID;
const EventType RespawnEventTypeID;
const EventType PreloadEventTypeID;
const EventType LogoutEventTypeID;
const EventType LoginStatusEventTypeID;
 
//-----------------------------------------------------------------------------
const EventType SelectedUserChangedEventTypeID;
const EventType ScriptLogEventTypeID;
 
//-----------------------------------------------------------------------------
const EventType VONStateEventTypeID;
const EventType VONStartSpeakingEventTypeID;
const EventType VONStopSpeakingEventTypeID;
const EventType VONUserStartedTransmittingAudioEventTypeID;
const EventType VONUserStoppedTransmittingAudioEventTypeID;
 
//-----------------------------------------------------------------------------
const EventType PartyChatStatusChangedEventTypeID;
const EventType DLCOwnerShipFailedEventTypeID;
const EventType SetFreeCameraEventTypeID;
const EventType ConnectingStartEventTypeID;
const EventType ConnectingAbortEventTypeID;
const EventType PlayerDeathEventTypeID;
 
//possible in engine events not accessable from script
//ReloadShadersEvent
//LoadWorldProgressEvent
 
//SignStatusEvent
//SetPausedEvent
//TerminationEvent
//UserSettingsChangedEvent
//StorageChangedEvent
//BeforeResetEvent
//AfterRenderEvent
//AfterResetEvent
//CrashLogEvent
//ConsoleEvent
 
class CursorIcons
{
  const string None = "";
  const string Cursor = "set:dayz_gui image:cursor";
  const string CloseDoors = "set:dayz_gui image:close";
  const string OpenDoors = "set:dayz_gui image:open";
  const string OpenCarDoors = "set:dayz_gui image:open_car";
  const string CloseCarDoors = "set:dayz_gui image:close_car";
  const string EngineOff = "set:dayz_gui image:engine_off";
  const string EngineOn = "set:dayz_gui image:engine_on";
  const string LadderDown = "set:dayz_gui image:ladderdown";
  const string LadderOff = "set:dayz_gui image:ladderoff";
  const string LadderUp = "set:dayz_gui image:ladderup";
  const string LootCorpse = "set:dayz_gui image:gear";
  const string CloseHood = "set:dayz_gui image:close_hood";
  const string OpenHood = "set:dayz_gui image:open_hood";
  const string GetOut = "set:dayz_gui image:getout";
  const string GetInCargo = "set:dayz_gui image:get_in_cargo";
  const string Reload = "set:dayz_gui image:reload";
  const string GetInDriver = "set:dayz_gui image:get_in_driver";
  const string GetInCommander = "set:dayz_gui image:get_in_commander";
  const string GetInPilot = "set:dayz_gui image:get_in_pilot";
  const string GetInGunner = "set:dayz_gui image:get_in_gunner";
};
 
 
// some defs for CGame::ShowDialog()
/*
  const int DBB_NONE = 0;
  const int DBB_OK = 1;
  const int DBB_YES = 2;
  const int DBB_NO = 3;
  const int DBB_CANCEL = 4;
 
  const int DBT_OK = 0;   //just OK button
  const int DBT_YESNO = 1;  //Yes and No buttons
  const int DBT_YESNOCANCEL = 2; //Yes, No, Cancel buttons
 
  const int DMT_NONE = 0;
  const int DMT_INFO = 1;
  const int DMT_WARNING = 2;
  const int DMT_QUESTION = 3;
  const int DMT_EXCLAMATION = 4;
*/
 
proto native CGame GetGame();
 
class Hud : Managed
{
  ref Timer m_Timer;
  void Init(Widget hud_panel_widget) {}
  void DisplayNotifier(int key, int tendency, int status) {}
  void DisplayBadge(int key, int value) {}
  void SetStamina(int value, int range) {}
  void DisplayStance(int stance) {}
  void DisplayPresence() {}
  void ShowCursor() { }
  void HideCursor() { }
  void SetCursorIcon(string icon) { }
  void SetCursorIconScale(string type, float percentage) { }
  void SetCursorIconOffset(string type, float x, float y) { }
  void SetCursorIconSize(string type, float x, float y) { }
  void ShowWalkieTalkie(bool show) { }
  void ShowWalkieTalkie(int fadeOutSeconds) { }
  void SetWalkieTalkieText(string text) { }
  void RefreshQuickbar(bool itemChanged = false) {}
  void Show(bool show) {}
  void UpdateBloodName() {}
  void SetTemperature(string temp);
  void SetStaminaBarVisibility(bool show);
  void Update(float timeslice) {}
  void ShowVehicleInfo();
  void HideVehicleInfo();
  void ToggleHeatBufferPlusSign(bool show);
 
  void ShowQuickbarUI(bool show);
  void ShowQuickbarPlayer(bool show);
  void ShowHudPlayer(bool show);
  void ShowHudUI(bool show);
  void ShowHudInventory(bool show);
  void ShowQuickBar(bool show);
  void UpdateQuickbarGlobalVisibility();
  void ShowHud(bool show);
 
  void OnResizeScreen();
 
  void SetPermanentCrossHair(bool show) {}
 
  void SpawnHitDirEffect(DayZPlayer player, float hit_direction, float intensity_max);
  void SetConnectivityStatIcon(EConnectivityStatType type, EConnectivityStatLevel level);
};
 
//-----------------------------------------------------------------------------
class Mission
{
  ScriptModule MissionScript;
 
  ref array<vector> m_ActiveRefresherLocations;
 
  protected ref ScriptInvoker m_OnInputDeviceChanged = new ScriptInvoker();
  protected ref ScriptInvoker m_OnInputPresetChanged = new ScriptInvoker();
  protected ref ScriptInvoker m_OnInputDeviceConnected = new ScriptInvoker();
  protected ref ScriptInvoker m_OnInputDeviceDisconnected = new ScriptInvoker();
  protected ref ScriptInvoker m_OnModMenuVisibilityChanged = new ScriptInvoker();
 
  private void ~Mission();
 
  void OnInit() {}
  void OnMissionStart() {}
  void OnMissionFinish() {}
  void OnUpdate(float timeslice)
  {
#ifdef FEATURE_CURSOR
    m_TimeStamp++;
#endif
  }
  void OnKeyPress(int key) {}
  void OnKeyRelease(int key) {}
  void OnMouseButtonPress(int button) {}
  void OnMouseButtonRelease(int button) {}
  void OnEvent(EventType eventTypeId, Param params) {}
  void OnItemUsed(InventoryItem item, Man owner) {}
  void AddDummyPlayerToScheduler(Man player) {}
  void Reset() {}
  void ResetGUI() {}
  void OnGameplayDataHandlerLoad() {}
 
  Hud GetHud()
  {
    return NULL;
  }
 
  ObjectSnapCallback GetInventoryDropCallback()
  {
    return NULL;
  }
 
  bool IsPlayerDisconnecting(Man player);
 
  UIScriptedMenu CreateScriptedMenu(int id)
  {
    return NULL;
  }
 
  UIScriptedWindow CreateScriptedWindow(int id)
  {
    return NULL;
  }
 
  WorldData GetWorldData()
  {
    return NULL;
  }
 
  WorldLighting GetWorldLighting()
  {
    return NULL;
  }
 
  bool IsPaused()
  {
    return false;
  }
 
  bool IsGame()
  {
    return false;
  }
 
  bool IsServer()
  {
    return false;
  }
 
  void Pause() {}
  void Continue() {}
 
  void AbortMission() {}
 
  void CreateLogoutMenu(UIMenuPanel parent) {}
  void StartLogoutMenu(int time) {}
 
  void CreateDebugMonitor() {}
  void HideDebugMonitor() {}
 
  void RefreshCrosshairVisibility() {}
 
  void HideCrosshairVisibility() {}
 
  bool IsMissionGameplay()
  {
    return false;
  }
 
  bool IsControlDisabled() {}
  int GetControlDisabledMode() {}
 
  void PlayerControlEnable(bool bForceSupress); 
  void PlayerControlDisable(int mode); 
 
  void RemoveActiveInputExcludes(array<string> excludes, bool bForceSupress = false);
  void RemoveActiveInputRestriction(int restrictor);
  void AddActiveInputExcludes(array<string> excludes);
  void AddActiveInputRestriction(int restrictor);
  void RefreshExcludes();
  bool IsInputExcludeActive(string exclude);
  bool IsInputRestrictionActive(int restriction);
  void EnableAllInputs(bool bForceSupress = false);
 
  void ShowInventory() {}
  void HideInventory() {}
 
  void ShowChat() {}
  void HideChat() {}
  void UpdateVoiceLevelWidgets(int level) {}
 
  void HideVoiceLevelWidgets() {}
  bool IsVoNActive() {}
  void SetVoNActive(bool active) {}
 
  bool InsertCorpse(Man player)
  {
    return false;
  }
 
  UIScriptedMenu GetNoteMenu() {};
  void SetNoteMenu(UIScriptedMenu menu) {};
  void SetPlayerRespawning(bool state);
  void OnPlayerRespawned(Man player);
  bool IsPlayerRespawning();
  array<vector> GetActiveRefresherLocations();
 
  void SetRespawnModeClient(int mode);
  int GetRespawnModeClient()
  {
    return -1;
  }
  void SyncRespawnModeInfo(PlayerIdentity identity) {};
 
  ImageWidget GetMicrophoneIcon()
  {
    return null;
  }
 
  WidgetFadeTimer GetMicWidgetFadeTimer() {}
 
  GameplayEffectWidgets_base GetEffectWidgets() {}
 
  map<int, ImageWidget> GetVoiceLevelWidgets() {}
 
  map<int, ref WidgetFadeTimer> GetVoiceLevelTimers() {}
 
  ScriptInvoker GetOnInputDeviceChanged()
  {
    if (!m_OnInputDeviceChanged)
      m_OnInputDeviceChanged = new ScriptInvoker;
 
    return m_OnInputDeviceChanged;
  }
 
  ScriptInvoker GetOnInputPresetChanged()
  {
    if (!m_OnInputPresetChanged)
      m_OnInputPresetChanged = new ScriptInvoker;
 
    return m_OnInputPresetChanged;
  }
 
  ScriptInvoker GetOnInputDeviceConnected()
  {
    if (!m_OnInputDeviceConnected)
      m_OnInputDeviceConnected = new ScriptInvoker;
 
    return m_OnInputDeviceConnected;
  }
 
  ScriptInvoker GetOnInputDeviceDisconnected()
  {
    if (!m_OnInputDeviceDisconnected)
      m_OnInputDeviceDisconnected = new ScriptInvoker;
 
    return m_OnInputDeviceDisconnected;
  }
 
  ScriptInvoker GetOnModMenuVisibilityChanged()
  {
    if (!m_OnModMenuVisibilityChanged)
      m_OnModMenuVisibilityChanged = new ScriptInvoker;
 
    return m_OnModMenuVisibilityChanged;
  }
 
#ifdef FEATURE_CURSOR
  int m_TimeStamp = 0;
  int GetTimeStamp() { return m_TimeStamp; }
#endif
 
#ifdef DEVELOPER
  bool m_SuppressNextFrame = true;
  void SetInputSuppression(bool state) {}
  bool GetInputSuppression() {}
#endif
};
 
// -------------------------------------------------------------------------
 
class MenuData: Managed
{
  proto native int GetCharactersCount();
  proto native int GetLastPlayedCharacter();
  proto native Man CreateCharacterPerson(int index);
 
  proto void GetLastServerAddress(int index, out string address);
  proto native int GetLastServerPort(int index);
  proto void GetLastServerName(int index, out string address);
 
  proto void RequestSetDefaultCharacterData();
  proto bool RequestGetDefaultCharacterData();
 
  void OnSetDefaultCharacter(ParamsWriteContext ctx)
  {
    if (!GetMenuDefaultCharacterDataInstance()/* || GetGame().IsServer()*/)
    {
      Error("MenuData | OnSetDefaultCharacter - failed to get data class!");
      return;
    }
 
    GetMenuDefaultCharacterDataInstance().SerializeCharacterData(ctx);
    SaveCharactersLocal();
  }
 
  bool OnGetDefaultCharacter(ParamsReadContext ctx)
  {
    if (!GetMenuDefaultCharacterDataInstance())
    {
      Error("MenuData | OnGetDefaultCharacter - failed to get data class!");
      return false;
    }
 
    if (GetMenuDefaultCharacterDataInstance().DeserializeCharacterData(ctx))
      return true;
    return false;
  }
 
  proto void GetCharacterName(int index, out string name);
  proto native void SetCharacterName(int index, string newName);
  // save character is set as last played character
  proto native void SaveCharacter(bool localPlayer, bool verified);
  proto native void SaveDefaultCharacter(Man character);
 
  proto native void SaveCharactersLocal();
  proto native void LoadCharactersLocal();
  proto native void ClearCharacters();
 
  MenuDefaultCharacterData GetMenuDefaultCharacterDataInstance()
  {
    return GetGame().GetMenuDefaultCharacterData();
  }
 
  //proto native void GetCharacterStringList(int characterID, string name, out TStringArray values);
  //proto bool      GetCharacterString(int characterID,string name, out string value);
};
 
//holds 'default character' data
class MenuDefaultCharacterData
{
  //const int MODE_SERVER = 0;
  //const int MODE_CLIENT = 1;
 
  string m_CharacterName;
  string m_CharacterType;
  ref map<int, string> m_AttachmentsMap;
  bool m_ForceRandomCharacter;
 
  void MenuDefaultCharacterData()
  {
    Init();
  }
 
  void Init()
  {
    if (!GetGame().IsDedicatedServer())
      GetGame().GetMenuData().LoadCharactersLocal();
    m_AttachmentsMap = new map<int, string>;
  }
 
  void ClearAttachmentsMap()
  {
    m_AttachmentsMap.Clear();
  }
 
  void SetDefaultAttachment(int slotID, string type)
  {
    m_AttachmentsMap.Set(slotID, type); //using 'Set' instead of 'Insert' for convenience
  }
 
  void GenerateRandomEquip()
  {
    ClearAttachmentsMap();
 
    int slot_ID;
    string attachment_type;
    for (int i = 0; i < DefaultCharacterCreationMethods.GetAttachmentSlotsArray().Count(); i++)
    {
      slot_ID = DefaultCharacterCreationMethods.GetAttachmentSlotsArray().Get(i);
      if (DefaultCharacterCreationMethods.GetConfigArrayCountFromSlotID(slot_ID) > 0)
      {
        attachment_type = DefaultCharacterCreationMethods.GetConfigAttachmentTypes(slot_ID).GetRandomElement();
        //if (attachment_type != "")
        SetDefaultAttachment(slot_ID, attachment_type);
      }
    }
  }
 
  void EquipDefaultCharacter(Man player)
  {
    if (!player)
    {
      ErrorEx("WARNING - trying to equip non-existent object! | MenuDefaultCharacterData::EquipDefaultCharacter");
      return;
    }
 
    int slot_ID;
    string attachment_type;
    string current_attachment_type;
    EntityAI current_attachment_object;
 
    for (int i = 0; i < m_AttachmentsMap.Count(); i++)
    {
      attachment_type = "";
      current_attachment_type = "";
      slot_ID = m_AttachmentsMap.GetKey(i);
      attachment_type = m_AttachmentsMap.GetElement(i); //Get(i)
      current_attachment_object = player.GetInventory().FindAttachment(slot_ID);
 
      if (current_attachment_object)
        current_attachment_type = current_attachment_object.GetType();
      if (current_attachment_type != attachment_type)
      {
        if (current_attachment_object)
          g_Game.ObjectDelete(current_attachment_object);
        if (attachment_type != "")
          player.GetInventory().CreateAttachmentEx(attachment_type, slot_ID);
      }
    }
  }
 
  void SerializeCharacterData(ParamsWriteContext ctx)
  {
    ctx.Write(m_CharacterType);
    ctx.Write(m_AttachmentsMap);
    ctx.Write(m_ForceRandomCharacter);
    ctx.Write(m_CharacterName);
    //DumpAttMapContents();
  }
 
  bool DeserializeCharacterData(ParamsReadContext ctx)
  {
    if (!ctx.Read(m_CharacterType))
      return false;
    if (!ctx.Read(m_AttachmentsMap))
      return false;
    if (!ctx.Read(m_ForceRandomCharacter))
      return false;
    if (!ctx.Read(m_CharacterName))
      return false;
 
    //DumpAttMapContents();
    return true;
  }
 
  void SetCharacterName(string name)
  {
    m_CharacterName = name;
  }
 
  string GetCharacterName()
  {
    return m_CharacterName;
  }
 
  void SetCharacterType(string character_type)
  {
    m_CharacterType = character_type;
  }
 
  string GetCharacterType()
  {
    return m_CharacterType;
  }
 
  void SetRandomCharacterForced(bool state)
  {
    m_ForceRandomCharacter = state;
  }
 
  bool IsRandomCharacterForced()
  {
    return m_ForceRandomCharacter;
  }
 
  map<int, string> GetAttachmentMap()
  {
    return m_AttachmentsMap;
  }
 
  //DEBUG
  void DumpAttMapContents()
  {
    int debugID;
    string debugType;
    Print("-----------");
    Print("m_AttachmentsMap contents:");
    for (int j = 0; j < m_AttachmentsMap.Count(); j++)
    {
      debugID = m_AttachmentsMap.GetKey(j);
      debugType = m_AttachmentsMap.GetElement(j);
      Print("index " + j);
      Print("debugID: " + debugID);
      Print("debugType: " + debugType);
    }
    Print("-----------");
  }
}
 
class DefaultCharacterCreationMethods
{
  static ref array<int> m_AttachmentSlots = {
    InventorySlots.SHOULDER,
    InventorySlots.MELEE,
    InventorySlots.HEADGEAR,
    InventorySlots.MASK,
    InventorySlots.EYEWEAR,
    InventorySlots.GLOVES,
    InventorySlots.ARMBAND,
    InventorySlots.BODY,
    InventorySlots.VEST,
    InventorySlots.BACK,
    InventorySlots.HIPS,
    InventorySlots.LEGS,
    InventorySlots.FEET
  };
  //conversion nescesssary for legacy reasons...
  static ref array<string> m_ConfigArrayNames = {
    "shoulder",
    "melee",
    "headgear",
    "mask",
    "eyewear",
    "gloves",
    "armband",
    "top",
    "vests",
    "backpacks",
    "hips",
    "bottom",
    "shoe"
  };
 
  const static string m_Path = "cfgCharacterCreation";
 
  static string GetPathFromSlotID(int slot_ID)
  {
    int idx = m_AttachmentSlots.Find(slot_ID);
    string path = "" + m_Path + " " + m_ConfigArrayNames.Get(idx);
    return path;
  }
 
  static int GetConfigArrayCountFromSlotID(int slot_ID)
  {
    TStringArray types = new TStringArray;
    GetGame().ConfigGetTextArray(GetPathFromSlotID(slot_ID), types);
    return types.Count();
  }
 
  static array<string> GetConfigAttachmentTypes(int slot_ID)
  {
    TStringArray types = new TStringArray;
    GetGame().ConfigGetTextArray(GetPathFromSlotID(slot_ID), types);
    return types;
  }
 
  static array<int> GetAttachmentSlotsArray()
  {
    return m_AttachmentSlots;
  }
 
  static array<string> GetConfigArrayNames()
  {
    return m_ConfigArrayNames;
  }
}
 
enum OptionAccessType
{
  AT_UNKNOWN,
  AT_OBJECTS_DETAIL,
  AT_TEXTURE_DETAIL,
  AT_HDR_DETAIL,
  AT_FSAA_DETAIL,
  AT_VSYNC_VALUE,
  AT_ANISO_DETAIL,
  AT_OPTIONS_FXAA_VALUE,
  AT_OPTIONS_SW_VALUE,
  AT_POSTPROCESS_EFFECTS,
  AT_QUALITY_PREFERENCE,
  AT_ATOC_DETAIL,
  AT_AMBIENT_OCCLUSION,
  AT_BLOOM,
  AT_ROTATION_BLUR,
  AT_SHADOW_DETAIL,
  AT_OPTIONS_TERRAIN,
  AT_OPTIONS_RESOLUTION,
  AT_OPTIONS_GAMMA_SLIDER,
  AT_OPTIONS_BRIGHT_SLIDER,
  AT_OPTIONS_VISIBILITY_SLIDER,
  AT_OPTIONS_OBJECT_VISIBILITY_SLIDER,
  AT_OPTIONS_SHADOW_VISIBILITY_SLIDER,
  AT_OPTIONS_DRAWDISTANCE_SLIDER,
  AT_ASPECT_RATIO,
  AT_OPTIONS_FIELD_OF_VIEW,
  AT_OPTIONS_MUSIC_SLIDER,
  AT_OPTIONS_EFFECTS_SLIDER,
  AT_OPTIONS_VON_SLIDER,
  AT_OPTIONS_MASTER_VOLUME,
  AT_OPTIONS_HWACC,
  AT_OPTIONS_EAX,
  AT_OPTIONS_LANGUAGE,
  AT_OPTIONS_RADIO,
  AT_CONFIG_MOUSE_FILTERING,
  AT_CONFIG_HEAD_BOB,
  AT_OPTIONS_DISPLAY_MODE,
  AT_OPTIONS_TERRAIN_SHADER,
  AT_OPTIONS_AIM_HELPER,
  AT_OPTIONS_MOUSE_AND_KEYBOARD,
  AT_OPTIONS_PAUSE,
  AT_OPTIONS_FLIPMODE,
  AT_OPTIONS_VON_THRESHOLD_SLIDER,
 
  AT_OPTIONS_MOUSE_YAXIS_INVERTED,
  AT_OPTIONS_MOUSE_XAXIS,
  AT_OPTIONS_MOUSE_YAXIS,
  AT_OPTIONS_MOUSE_XAXIS_AIM_MOD,
  AT_OPTIONS_MOUSE_YAXIS_AIM_MOD,
 
  AT_OPTIONS_CONTROLLER_LS_XAXIS,
  AT_OPTIONS_CONTROLLER_LS_YAXIS,
  AT_OPTIONS_CONTROLLER_LS_XAXIS_VEHICLE_MOD,
  AT_OPTIONS_CONTROLLER_RS_YAXIS_INVERTED,
  AT_OPTIONS_CONTROLLER_RS_XAXIS,
  AT_OPTIONS_CONTROLLER_RS_YAXIS,
  AT_OPTIONS_CONTROLLER_RS_XAXIS_AIM_MOD,
  AT_OPTIONS_CONTROLLER_RS_YAXIS_AIM_MOD,
  AT_OPTIONS_VON_INPUT_MODE
};
 
enum OptionIDsScript
{
  OPTION_HUD = 100, //starts at 100 to avoid ID conflict with AT_
  OPTION_CROSSHAIR,
  OPTION_GAME_MESSAGES,
  OPTION_ADMIN_MESSAGES,
  OPTION_PLAYER_MESSAGES,
  OPTION_QUICKBAR,
  OPTION_SERVER_INFO,
  OPTION_BLEEDINGINDICATION,
  OPTION_CONNECTIVITY_INFO,
  OPTION_HUD_BRIGHTNESS
};
 
// -------------------------------------------------------------------------
/*
  // Option Access Control Type
  const int OA_CT_NUMERIC = 0;
  const int OA_CT_SWITCH = 1;
  const int OA_CT_LIST = 2;
 
  // Option Field of view constants
  const float OPTIONS_FIELD_OF_VIEW_MIN = 0.75242724772f;
  const float OPTIONS_FIELD_OF_VIEW_MAX = 1.30322025726f;
*/
 
class OptionsAccess: Managed
{
  //proto private void ~OptionsAccess();
  //proto private void OptionsAccess();
 
  proto native int GetAccessType();
 
  proto native int GetControlType();
 
  proto native void Apply();
 
  proto native void Test();
 
  proto native void Revert();
 
  proto native int IsChanged();
 
  proto native int NeedRestart();
 
  proto native int SetChangeImmediately();
  //proto native  void  Initialize();
 
 
  private proto void SetScriptEvents(Managed events);
 
  private proto Managed GetScriptEvents();
 
  OptionsAccessEvents GetEvents()
  {
    return OptionsAccessEvents.Cast(GetScriptEvents());
  }
 
 
 
 
  void OnRevert()
  {
    GetEvents().Event_OnRevert.Invoke(this);
  }
 
};
 
class OptionsAccessEvents
{
  ref ScriptInvoker Event_OnRevert = new ScriptInvoker();
}
 
// -------------------------------------------------------------------------
class NumericOptionsAccess extends OptionsAccess
{
  proto native float ReadValue();
  proto native void WriteValue(float value);
  proto native float GetMin();
  proto native float GetMax();
  proto native float GetDefault();
};
 
// -------------------------------------------------------------------------
class ListOptionsAccess extends OptionsAccess
{
  proto native int GetIndex();
  proto native int GetDefaultIndex();
  proto native void SetIndex(int index);
  proto native int GetItemsCount();
  proto void GetItemText(int index, out string value);
};
 
// -------------------------------------------------------------------------
class SwitchOptionsAccess extends OptionsAccess
{
  proto native void Switch();
  proto void GetItemText(out string value);
  proto native int GetIndex();
  proto native int GetDefaultIndex();
};
 
// -------------------------------------------------------------------------
class GameOptions: Managed
{
  proto native void Apply();
 
  proto native void Revert();
 
  proto native void Test();
 
  proto native OptionsAccess GetOption(int index);
 
  proto native OptionsAccess GetOptionByType(int accessType);
 
  proto native int GetOptionsCount();
 
  proto native int NeedRestart();
 
  proto native int IsChanged();
 
  proto native void Initialize();
};
 
 
typedef Link<Object> OLinkT;
 
EntityAI SpawnEntity(string object_name, notnull InventoryLocation inv_loc, int iSetupFlags, int iRotation)
{
  return GameInventory.LocationCreateEntity(inv_loc, object_name, iSetupFlags, iRotation);
}
 
class Static : Object
{
};
 
 
class PrtTest // Temporal class for toggling particles on guns
{
  static bool m_GunParticlesState = true;
}
 
// #include "Scripts/Classes/Component/_include.c"