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 owned string GetName();
    proto owned string GetPlainName();
    proto owned string GetFullName();
    proto owned string GetId();
    proto owned 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 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();
 
    private void ~Mission();
    
    void OnInit()   {}
    void OnMissionStart() {}
    void OnMissionFinish()  {}
    void OnUpdate(float timeslice) {}
    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 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;
    }
    
#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"