CAContinuousMineWood.c

Go to the documentation of this file.

class CAContinuousMineWood : CAContinuousBase
{
  protected float m_TimeElpased;
  protected float m_AdjustedTimeBetweenMaterialDrops;
  protected float m_CycleTimeOverride;
  protected float m_TimeBetweenMaterialDrops;
  protected float m_DamageToMiningItemEachDrop;
  protected float m_AdjustedDamageToMiningItemEachDrop;
  protected int m_AmountOfDrops;
  protected int m_CurrentAssumedDrops;
  protected ref map<string, int> m_MaterialAndQuantityMap;
  protected float m_TimeToComplete;
  protected ref Param1<float> m_SpentUnits;
  protected bool m_DataLoaded = false;
  protected const int MINEDITEM_MAX = 5;
  protected ItemBase m_MinedItem[MINEDITEM_MAX];
  protected ItemBase m_SecondaryItem;
 
  void CAContinuousMineWood(float time_between_drops)
  {
    m_TimeBetweenMaterialDrops = time_between_drops;
    m_CycleTimeOverride = -1.0;
  }
 
  override void Setup(ActionData action_data)
  {
    m_TimeElpased = 0;
    if (!m_SpentUnits)
      m_SpentUnits = new Param1<float>(0);
    else
      m_SpentUnits.param1 = 0;
    m_MaterialAndQuantityMap = new map<string, int>;
    m_DataLoaded = GetMiningData(action_data);
 
    if (m_CycleTimeOverride > -1.0)
    {
      m_TimeBetweenMaterialDrops = m_CycleTimeOverride;
      if (!action_data.m_MainItem) //hand action
        m_TimeBetweenMaterialDrops = m_TimeBetweenMaterialDrops * 3;
    }
    m_AdjustedTimeBetweenMaterialDrops = action_data.m_Player.GetSoftSkillsManager().SubtractSpecialtyBonus(m_TimeBetweenMaterialDrops, m_Action.GetSpecialtyWeight(), true);
    m_TimeToComplete = m_AmountOfDrops * m_AdjustedTimeBetweenMaterialDrops;
  }
 
  override int Execute(ActionData action_data)
  {
    Object targetObject;
    Class.CastTo(targetObject, action_data.m_Target.GetObject());
    if (!action_data.m_Player || !m_DataLoaded)
      return UA_ERROR;
 
    if ((action_data.m_MainItem && action_data.m_MainItem.IsDamageDestroyed()) || targetObject.IsDamageDestroyed())
      return UA_FINISHED;
    else
    {
      if (m_TimeElpased < m_AdjustedTimeBetweenMaterialDrops)
        m_TimeElpased += action_data.m_Player.GetDeltaT();
      else
      {
        if (GetGame().IsServer())
        {
          float damage = 0;
          if (m_AmountOfDrops > 0)
            damage = (1 / m_AmountOfDrops) * 100;
 
          targetObject.DecreaseHealth("", "", damage, targetObject.CanBeAutoDeleted());
          CreatePrimaryItems(action_data);
          if (action_data.m_MainItem)
            action_data.m_MainItem.DecreaseHealth("", "", m_AdjustedDamageToMiningItemEachDrop);
          else
            DamagePlayersHands(action_data.m_Player);
 
          if (targetObject.IsDamageDestroyed()) //client does not know the target is destroyed yet, happens on the next Execute!
          {
            if (m_SpentUnits)
            {
              m_SpentUnits.param1 = m_TimeElpased;
              SetACData(m_SpentUnits);
            }
 
            if (WoodBase.Cast(targetObject))
            {
              WoodBase target_woodbase = WoodBase.Cast(targetObject);
 
              if (target_woodbase.GetSecondaryOutput() != "")
                CreateSecondaryItems(action_data, target_woodbase.GetSecondaryOutput(), target_woodbase.GetSecondaryDropsAmount());
            }
 
            if (action_data.m_MainItem)
              targetObject.OnTreeCutDown(action_data.m_MainItem);
            else
              targetObject.OnTreeCutDown(action_data.m_Player);
          }
        }
 
        m_CurrentAssumedDrops++;
        if (m_AmountOfDrops > 0 && m_CurrentAssumedDrops >= m_AmountOfDrops) //assumed end, client does not know the target is destroyed yet
        {
          OnCompletePogress(action_data);
          return UA_FINISHED;
        }
 
        m_TimeElpased = m_TimeElpased - m_AdjustedTimeBetweenMaterialDrops;
        OnCompletePogress(action_data);
      }
      return UA_PROCESSING;
    }
  }
 
  override float GetProgress()
  {
    return m_TimeElpased / m_AdjustedTimeBetweenMaterialDrops;
  }
 
  //---------------------------------------------------------------------------
 
  bool GetMiningData(ActionData action_data)
  {
    MineActionData adata = MineActionData.Cast(action_data);
    WoodBase ntarget;
    if (Class.CastTo(ntarget, action_data.m_Target.GetObject()))
    {
      m_AmountOfDrops = ntarget.GetAmountOfDropsEx(action_data.m_MainItem, adata.m_HarvestType);
      m_CurrentAssumedDrops = 0;
      m_CycleTimeOverride = ntarget.GetCycleTimeOverride(); //TODO
      ntarget.GetMaterialAndQuantityMapEx(action_data.m_MainItem, m_MaterialAndQuantityMap, adata.m_HarvestType);
      m_DamageToMiningItemEachDrop = ntarget.GetDamageToMiningItemEachDropEx(action_data.m_MainItem, adata.m_HarvestType);
      m_AdjustedDamageToMiningItemEachDrop = action_data.m_Player.GetSoftSkillsManager().SubtractSpecialtyBonus(m_DamageToMiningItemEachDrop, m_Action.GetSpecialtyWeight(), true);
      return true;
    }
    return false;
  }
 
  void CreatePrimaryItems(ActionData action_data)
  {
    string material;
    int increment;
    for (int i = 0; i < m_MaterialAndQuantityMap.Count(); i++)
    {
      material = m_MaterialAndQuantityMap.GetKey(i);
 
      if (material != "")
      {
        increment = m_MaterialAndQuantityMap.GetElement(i);
 
        if (!m_MinedItem[i])
        {
          m_MinedItem[i] = ItemBase.Cast(GetGame().CreateObjectEx(material, action_data.m_Player.GetPosition(), ECE_PLACE_ON_SURFACE));
          m_MinedItem[i].SetQuantity(increment);
        }
        else if (m_MinedItem[i].HasQuantity())
        {
          if (m_MinedItem[i].IsFullQuantity())
          {
            int stack_max = m_MinedItem[i].GetQuantityMax();
 
            increment -= stack_max - m_MinedItem[i].GetQuantity();
            if (increment >= 1.0)
            {
              m_MinedItem[i] = ItemBase.Cast(GetGame().CreateObjectEx(material, action_data.m_Player.GetPosition(), ECE_PLACE_ON_SURFACE));
              m_MinedItem[i].SetQuantity(increment, false);
            }
          }
          else
            m_MinedItem[i].AddQuantity(increment, false);
        }
        else
          m_MinedItem[i] = ItemBase.Cast(GetGame().CreateObjectEx(material, action_data.m_Player.GetPosition(), ECE_PLACE_ON_SURFACE));
      }
    }
  }
 
  void CreateSecondaryItems(ActionData action_data, string material_secondary = "", int quantity_secondary = -1)
  {
    if (material_secondary == "" || quantity_secondary <= 0)
      return;
 
    m_SecondaryItem = ItemBase.Cast(GetGame().CreateObjectEx(material_secondary, action_data.m_Player.GetPosition(), ECE_PLACE_ON_SURFACE));
    if (!m_SecondaryItem.HasQuantity())
    {
      CreateSecondaryItems(action_data, material_secondary, quantity_secondary - 1);
      return;
    }
 
    int increment = quantity_secondary;
    int stack_max = m_SecondaryItem.GetQuantityMax();
    int stacks_amount;
 
    stacks_amount = Math.Ceil(increment / stack_max);
 
    for (int i = 0; i < stacks_amount; i++)
    {
      if (increment > stack_max)
      {
        m_SecondaryItem.SetQuantity(stack_max);
        increment -= stack_max;
        m_SecondaryItem = ItemBase.Cast(GetGame().CreateObjectEx(material_secondary, action_data.m_Player.GetPosition(), ECE_PLACE_ON_SURFACE));
      }
      else
        m_SecondaryItem.SetQuantity(increment);
    }
  }
 
  void DamagePlayersHands(PlayerBase player)
  {
    ItemBase gloves = ItemBase.Cast(player.FindAttachmentBySlotName("Gloves"));
    if (gloves && !gloves.IsDamageDestroyed())
      gloves.DecreaseHealth("", "", m_AdjustedDamageToMiningItemEachDrop);
    else
    {
      int rand = Math.RandomIntInclusive(0, 9);
      if (rand == 0)
      {
        rand = Math.RandomIntInclusive(0, 1);
        if (rand == 0 && !player.GetBleedingManagerServer().AttemptAddBleedingSourceBySelection("LeftForeArmRoll"))
          player.GetBleedingManagerServer().AttemptAddBleedingSourceBySelection("RightForeArmRoll");
        else if (rand == 1 && !player.GetBleedingManagerServer().AttemptAddBleedingSourceBySelection("RightForeArmRoll"))
          player.GetBleedingManagerServer().AttemptAddBleedingSourceBySelection("LeftForeArmRoll");
      }
    }
  }
};