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_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");
                }
            }
        }
    }
};