pluginrepairing.c

Go to the documentation of this file.

class PluginRepairing extends PluginBase
{
    bool Repair(PlayerBase player, ItemBase repair_kit, Object item, float specialty_weight, string damage_zone = "", bool use_kit_qty = true)
    {
        switch (item.GetHealthLevel(damage_zone))
        {
            case GameConstants.STATE_PRISTINE:
                break;
            case GameConstants.STATE_RUINED:
                #ifdef DEVELOPER
                Debug.Log("repairing from GameConstants.STATE_RUINED");
                #endif
                CalculateHealth( player, repair_kit, item, specialty_weight, damage_zone, use_kit_qty );
                break;
            case GameConstants.STATE_WORN:
                if (CanRepairToPristine(player) || CanBeRepairedToPristine(item))
                {
                    CalculateHealth( player, repair_kit, item, specialty_weight,/* GameConstants.DAMAGE_PRISTINE_VALUE,*/ damage_zone, use_kit_qty );
                }
                break;
            default:
                CalculateHealth( player, repair_kit, item, specialty_weight, damage_zone, use_kit_qty );
                break;
        }
 
        return true;
    }
 
    void CalculateHealth( PlayerBase player, ItemBase kit, Object item, float specialty_weight, string damage_zone = "", bool use_kit_qty = true )
    {
        EntityAI entity;
        Class.CastTo(entity,item);
        
        if (entity != null)
        {
            entity.SetAllowDamage(true);
        }
        
        bool kit_has_quantity = kit.HasQuantity();
        int health_levels_count = item.GetNumberOfHealthLevels(damage_zone);
        float cur_kit_quantity = kit.GetQuantity();
        float kit_repair_cost_per_level = GetKitRepairCost( kit, item );
        float kit_repair_cost_adjusted; //used with specialty_weight, disconnected
        float new_quantity;
        
        int target_level = Math.Clamp(item.GetHealthLevel(damage_zone) - 1, 0, health_levels_count - 1);
        float health_coef;
        if ( !CanRepairToPristine( player ) && !CanBeRepairedToPristine( item ) )
        {
            target_level = Math.Clamp(target_level, GameConstants.STATE_WORN, health_levels_count - 1);
        }
        health_coef = item.GetHealthLevelValue(target_level,damage_zone);
        
        //handles kit depletion; TODO: move to separate method.
        if ( cur_kit_quantity > kit_repair_cost_per_level )
        {
            kit_repair_cost_adjusted = kit_repair_cost_per_level; //TODO: removed speciality weight for now, it should affect speed only (?).
            //kit_repair_cost_adjusted = player.GetSoftSkillsManager().SubtractSpecialtyBonus( kit_repair_cost_per_level, specialty_weight );
            kit_repair_cost_adjusted = Math.Clamp( kit_repair_cost_adjusted, 0, 100 );
            if(use_kit_qty)
            {
                new_quantity = kit.GetQuantity() - kit_repair_cost_adjusted;
                kit.SetQuantity( new_quantity );
            }
        }
        else if (!kit_has_quantity) //"kit" without quantity (hammers and such) for your every day repairing needs
        {
        }
        else
        {
            if(use_kit_qty)
            {
                kit.SetQuantity( 0 );
            }
        }
        
        if (item.GetHealth01(damage_zone,"Health") < health_coef)
        {
            item.SetHealth01(damage_zone,"Health",health_coef);
        }
        
        if (entity != null)
        {
            entity.ProcessInvulnerabilityCheck(entity.GetInvulnerabilityTypeString());
        }
    }
 
    bool CanRepair( ItemBase repair_kit, Object item, string damage_zone = "" )
    {
        int state = item.GetHealthLevel(damage_zone);
        
        if ( state != GameConstants.STATE_RUINED && (item.CanBeRepairedToPristine() && state >= GameConstants.STATE_WORN) || (!item.CanBeRepairedToPristine() && state >= GameConstants.STATE_DAMAGED ) )
        {
            int repair_kit_type = repair_kit.ConfigGetInt( "repairKitType" );
            
            array<int> repairable_with_types = new array<int>;
            item.ConfigGetIntArray( "repairableWithKits", repairable_with_types );  
            
            for ( int i = 0; i < repairable_with_types.Count(); i++ )
            {
                int repairable_with_type = repairable_with_types.Get(i);
                
                if ( IsRepairValid( repair_kit_type, repairable_with_type ) )
                {
                    return true;
                }
            }
        }
        return false;
        
    }
    
    private bool IsRepairValid(int repair_kit_type, int repairable_with_type)
    {
        if (repair_kit_type > 0 && repairable_with_type > 0)
        {
            return repair_kit_type == repairable_with_type;
        }
        
        return false;
    }
 
    private bool CanRepairToPristine(PlayerBase player)
    {
        return false; 
    }
    
    private bool CanBeRepairedToPristine(Object item)
    {
        return item.CanBeRepairedToPristine();
    }
    
    private float GetKitRepairCost(ItemBase repair_kit, Object item)
    {
        array<int> allowedRepairKitTypes    = new array<int>(); 
        array<float> repairKitCosts         = new array<float>();
        
        item.ConfigGetIntArray("repairableWithKits", allowedRepairKitTypes);
        item.ConfigGetFloatArray("repairCosts", repairKitCosts);
        
        int repairKitType = repair_kit.ConfigGetInt("repairKitType");
        
        foreach (int i, int allowedKitType : allowedRepairKitTypes)
        {
            if (allowedKitType == repairKitType)
            {
                return repairKitCosts.Get(i);
            }
        } 
                    
        return 0;
    }
}