QuickBarBase.c

Go to the documentation of this file.

const int MAX_QUICKBAR_SLOTS_COUNT = 10;
// Script File
class QuickBarItem
{
  EntityAI m_entity;
  bool m_enabled;
 
  void QuickBarItem()
  {
    m_entity = NULL;
    m_enabled = false;
  }
}
 
class QuickBarBase
{
  protected ref QuickBarItem m_aQuickbarEnts[MAX_QUICKBAR_SLOTS_COUNT];
  protected PlayerBase _player;
  protected int m_slotsCount;
 
  void QuickBarBase(PlayerBase player)
  {
    for (int i = 0; i < MAX_QUICKBAR_SLOTS_COUNT; i++)
    {
      m_aQuickbarEnts[i] = new QuickBarItem;
      m_aQuickbarEnts[i].m_enabled = false;
      m_aQuickbarEnts[i].m_entity = NULL;
    }
 
    _player = player;
    m_slotsCount = 0;
  }
  //-------------------------------------------------------------
  void SetSize(int newSize)
  {
    int i = m_slotsCount;
    if (newSize == m_slotsCount)
      return;
 
    if (newSize > MAX_QUICKBAR_SLOTS_COUNT)
      newSize = MAX_QUICKBAR_SLOTS_COUNT;
 
    if (newSize > i)
    {
      for (; i < newSize; i++)
      {
        EntityAI entity = m_aQuickbarEnts[i].m_entity;
        if (entity != NULL && entity.GetHierarchyRootPlayer() == _player)
          m_aQuickbarEnts[i].m_enabled = true;
      }
    }
    else
    {
      for (i--; i >= newSize; i--)
        m_aQuickbarEnts[i].m_enabled = false;
    }
 
    m_slotsCount = newSize;
 
    if (_player.m_Hud)
      _player.m_Hud.RefreshQuickbar(true);
  }
  //-------------------------------------------------------------
  int GetNonEmptyCount()
  {
    int count = 0;
    for (int i = 0; i < m_slotsCount; i++)
    {
      if (m_aQuickbarEnts[i].m_enabled)
        count++;
    }
 
    return count;
  }
  //-------------------------------------------------------------
  EntityAI GetEntity(int index)
  {
    if (index < 0 || index >= m_slotsCount)
      return NULL;
 
    if (m_aQuickbarEnts[index].m_enabled)
      return m_aQuickbarEnts[index].m_entity;
 
    return NULL;
  }
 
  //-------------------------------------------------------------
  int GetSize()
  {
    return m_slotsCount;
  }
  //-------------------------------------------------------------
  int FindEntityIndex(EntityAI entity)
  {
    for (int i = 0; i < MAX_QUICKBAR_SLOTS_COUNT; i++)
    {
      if (m_aQuickbarEnts[i].m_entity == entity)
        return i;
    }
 
    return -1;
  }
  //-------------------------------------------------------------
  bool OnInputUserDataProcess(int userDataType, ParamsReadContext ctx)
  {
    if (userDataType == INPUT_UDT_QUICKABARSHORTCUT)
    {
      OnSetEntityRequest(ctx);
      return true;
    }
 
    return false;
  }
  //-------------------------------------------------------------
  void UpdateShotcutVisibility(int index)
  {
    m_aQuickbarEnts[index].m_enabled = CanAddAsShortcut(m_aQuickbarEnts[index].m_entity);
    if (!m_aQuickbarEnts[index].m_enabled)
      CancelContinuousUse(index);
 
    if (_player.m_Hud)
      _player.m_Hud.RefreshQuickbar(true);
  }
  //-------------------------------------------------------------
  void SetShotcutEnable(int index, bool value)
  {
    m_aQuickbarEnts[index].m_enabled = value && CanAddAsShortcut(m_aQuickbarEnts[index].m_entity);
    if (!m_aQuickbarEnts[index].m_enabled)
      CancelContinuousUse(index);
 
    if (_player.m_Hud)
      _player.m_Hud.RefreshQuickbar(true);
  }
  //-------------------------------------------------------------
  bool CanAddAsShortcut(EntityAI entity)
  {
    InventoryLocation loc = new InventoryLocation;
    entity.GetInventory().GetCurrentInventoryLocation(loc);
    EntityAI parent = loc.GetParent();
 
    return (entity && entity.GetHierarchyRootPlayer() == _player && parent.CanAssignAttachmentsToQuickbar() && entity.CanAssignToQuickbar());
  }
  //-------------------------------------------------------------
  void SetEntityShortcut(EntityAI entity, int index, bool force = false)
  {
    //Client
    if (GetGame().IsClient())
    {
      if (ScriptInputUserData.CanStoreInputUserData())
      {
        ScriptInputUserData ctx = new ScriptInputUserData;
        ctx.Write(INPUT_UDT_QUICKABARSHORTCUT);
        ctx.Write(entity);
        ctx.Write(index);
        ctx.Write(force);
        ctx.Send();
 
        _SetEntityShortcut(entity, index, force);
      }
    }
    //Server
    else if (GetGame().IsMultiplayer() && GetGame().IsServer())
      DayZPlayerSyncJunctures.SendQuickbarSetShortcut(_player, entity, index, force);
    else
    {
      // Single player
      _SetEntityShortcut(entity, index, force);
    }
  }
  //-------------------------------------------------------------
  void OnSetEntityNoSync(EntityAI entity, int index, bool force = false)
  {
    _SetEntityShortcut(entity, index, force);
  }
  //-------------------------------------------------------------
  void OnSetEntityRPC(ParamsReadContext ctx)
  {
    Param2<Entity, int> param;
    if (!ctx.Read(param))
      return;
 
    EntityAI entity1 = EntityAI.Cast(param.param1);
    _SetEntityShortcut(entity1, param.param2, false);
  }
  //-------------------------------------------------------------
  void OnSetEntityRequest(ParamsReadContext ctx)
  {
    EntityAI eai = null;
    if (!ctx.Read(eai))
      return;
 
    int index = -1;
    if (!ctx.Read(index))
      return;
 
    bool force = false;
    if (!ctx.Read(force))
      return
 
        _SetEntityShortcut(eai, index, force);
  }
  //-------------------------------------------------------------
  protected void _SetEntityShortcut(EntityAI entity, int index, bool force = false)
  {
    //TODO Check, if is in inventory
    //if(entity.GetLoca)
    if (entity == NULL)
    {
      _RemoveEntity(index);
      return;
    }
 
    int i = FindEntityIndex(entity);
 
    if (i != -1)
      _RemoveEntity(i);
 
    _RemoveEntity(index);
    _SetEntity(entity, index, force);
  }
  //-------------------------------------------------------------
  void updateSlotsCount()
  {
    int slotsCount = _player.GetQuickBarBonus();
    int attCount = _player.GetInventory().AttachmentCount();
 
    for (int i = 0; i < attCount; ++i)
      slotsCount += _player.GetInventory().GetAttachmentFromIndex(i).GetQuickBarBonus();
 
    //max slots is 10
    SetSize(Math.Min(slotsCount, 10));
  }
  //-------------------------------------------------------------
  protected void _RemoveEntity(int index)
  {
    if (index >= 0 && index < MAX_QUICKBAR_SLOTS_COUNT)
    {
      CancelContinuousUse(index);
 
      m_aQuickbarEnts[index].m_entity = NULL;
      m_aQuickbarEnts[index].m_enabled = false;
 
      if (_player.m_Hud)
        _player.m_Hud.RefreshQuickbar(true);
    }
  }
  //-------------------------------------------------------------
  protected void _SetEntity(EntityAI entity, int index, bool force = false)
  {
    if (index >= 0 && index < MAX_QUICKBAR_SLOTS_COUNT)
    {
      if (CanAddAsShortcut(entity))
      {
        m_aQuickbarEnts[index].m_entity = entity;
        m_aQuickbarEnts[index].m_enabled = true;
      }
      else
      {
        CancelContinuousUse(index);
        m_aQuickbarEnts[index].m_enabled = false;
      }
 
      if (_player.m_Hud)
        _player.m_Hud.RefreshQuickbar(true);
    }
  }
  //-------------------------------------------------------------
  void ~QuickBarBase()
  {
 
  }
  //-------------------------------------------------------------
  protected void CancelContinuousUse(int index)
  {
    if (_player.m_QuickBarHold)
    {
      HumanInputController hic = _player.GetInputController();
      if (hic && hic.IsQuickBarSlot() == index + 1)
        _player.OnQuickBarContinuousUseEnd(index + 1);
    }
  }
}