actionpushcar.c

Go to the documentation of this file.

class ActionPushCarDataReceiveData : ActionReciveData
{
    CarScript m_Car;
}
 
class ActionPushCarData : ActionData
{
    int m_PushDirection = -1;
    int m_EndType       = 0;
 
    float m_HorizontalDirectionRandom   = 1.0;
    float m_VerticalDirectionRandom     = 1.0;
 
    vector m_Origin = "0 0 0";
 
    bool m_NeedUpdate;
    CarScript m_Car;
}
 
class CAContinuousRepeatPushCar : CAContinuousRepeat
{
    void CAContinuousRepeatPushCar(float time_to_complete_action)
    {
        m_DefaultTimeToComplete = time_to_complete_action;
    }
    
    override int Execute(ActionData action_data)
    {
        if (!action_data.m_Player)
            return UA_ERROR;
 
        if (m_TimeElpased < m_TimeToComplete)
        {
            m_TimeElpased += action_data.m_Player.GetDeltaT();
            m_TotalTimeElpased += action_data.m_Player.GetDeltaT();
            return UA_PROCESSING;
        }
        else
        {
            m_SpentUnits.param1 = m_TimeElpased;
            SetACData(m_SpentUnits);
            m_TimeElpased = m_TimeToComplete - m_TimeElpased;
            OnCompletePogress(action_data);
 
            return UA_CANCEL;
        }
        
        return UA_FINISHED;
    }
}
 
class ActionPushCarCB : ActionContinuousBaseCB
{
    private static float PUSH_FORCE_IMPULSE_INCREMENT = 200.0;
    private ActionPushCarData m_ActionDataPushCar;
 
    override void CreateActionComponent()
    {
        m_ActionData.m_ActionComponent = new CAContinuousRepeatPushCar(10.0);
    }
    
    override void ProgressActionComponent()
    {
        super.ProgressActionComponent();
        
        ActionPushCarData data = ActionPushCarData.Cast(m_ActionData);
        ApplyForce(data);
    }
    
    override void EndActionComponent()
    {
        m_ActionDataPushCar = ActionPushCarData.Cast(m_ActionData);
        
        if (!m_ActionDataPushCar)
        {
            super.EndActionComponent();
            return;
        }
        
        if (m_ActionDataPushCar.m_State == UA_FINISHED)
        {
            if (m_ActionDataPushCar.m_EndType == 1)
                SetCommand(DayZPlayerConstants.CMD_ACTIONINT_FINISH);
            else if (m_ActionDataPushCar.m_EndType == 0)
                SetCommand(DayZPlayerConstants.CMD_ACTIONINT_END);
        }
        else if (m_ActionDataPushCar.m_State == UA_CANCEL)
        {
            ActionContinuousBase action = ActionContinuousBase.Cast(m_ActionDataPushCar.m_Action);
            if (action.HasAlternativeInterrupt())
                SetCommand(DayZPlayerConstants.CMD_ACTIONINT_FINISH);
            else
                SetCommand(DayZPlayerConstants.CMD_ACTIONINT_END);
 
            return;
        }
 
        m_ActionDataPushCar.m_State = UA_FINISHED;
    }
    
    protected void ApplyForce(ActionPushCarData actionData)
    {   
        CarScript car = actionData.m_Car;
        
        actionData.m_HorizontalDirectionRandom = Math.RandomFloat(1.0, 3.5);
        actionData.m_VerticalDirectionRandom = Math.RandomFloat(-0.5, 0.5);
        
        float bodyMass = dBodyGetMass(car);
        float invBodyMass = 1.0 / bodyMass;
        float force = dBodyGetMass(car) * PUSH_FORCE_IMPULSE_INCREMENT * car.GetPushForceCoefficientMultiplier();
        
        float easedProgress = Easing.EaseInOutSine(actionData.m_ActionComponent.GetProgress());
        
        vector impulse  = car.GetDirection() * force * (float)actionData.m_PushDirection;
        impulse         = impulse * invBodyMass;
        impulse[0]      = impulse[0] * actionData.m_HorizontalDirectionRandom;
        impulse[1]      = impulse[1] * actionData.m_VerticalDirectionRandom;
        impulse         = impulse * easedProgress;
        
        actionData.m_Player.DepleteStamina(EStaminaModifiers.PUSH_CAR);
 
        dBodyApplyImpulseAt(car, impulse, car.ModelToWorld(car.GetEnginePos()));    
    }
}
 
class ActionPushCar : ActionContinuousBase
{
    void ActionPushCar()
    {
        m_CallbackClass = ActionPushCarCB;
        m_CommandUID    = DayZPlayerConstants.CMD_ACTIONFB_VEHICLE_PUSH;
        m_FullBody      = true;
        m_StanceMask    = DayZPlayerConstants.STANCEMASK_ERECT;
 
        m_Text = "#push_car";
    }
    
    override typename GetInputType()
    {
        return ContinuousInteractActionInput;
    }
 
    override void CreateConditionComponents()
    {
        m_ConditionItem     = new CCINotPresent();
        m_ConditionTarget   = new CCTCursorNoRuinCheck(UAMaxDistances.DEFAULT);
    }
    
    override bool HasAlternativeInterrupt()
    {
        return true;
    }
    
    override ActionData CreateActionData()
    {
        ActionPushCarData data = new ActionPushCarData();
        return data;
    }
 
    override bool ActionCondition(PlayerBase player, ActionTarget target, ItemBase item)
    {
        if (!player.IsPlayerInStance(DayZPlayerConstants.STANCEMASK_ERECT|DayZPlayerConstants.STANCEMASK_CROUCH))
            return false;
        
        if (!player.GetSurfaceType())
            return false;
 
        if (!IsInReach(player, target, UAMaxDistances.SMALL))
            return false;
        
        if (!player.CanConsumeStamina(EStaminaConsumers.PUSH))
            return false;
 
        CarScript car = GetCar(target);
        if (car)
        {
            if (car.GetGear() != CarGear.NEUTRAL)
                return false;
 
            if (Math.AbsFloat(GetDirectionDot(car, player)) < 0.85)
                return false;
 
            return true;
        }
        
        return false;
    }
    
    override void OnUpdate(ActionData action_data)
    {
        super.OnUpdate(action_data);
 
        ActionPushCarData data = ActionPushCarData.Cast(action_data);       
        if (data.m_NeedUpdate)
        {
            if (!data.m_Player.CanConsumeStamina(EStaminaConsumers.PUSH))
            {
                data.m_State        = UA_CANCEL;
                data.m_NeedUpdate   = false;
 
                return;
            }
    
            if (vector.Distance(data.m_Car.GetPosition(), data.m_Origin) > 0.5)
            {
                data.m_State        = UA_FINISHED;
                data.m_EndType      = 0;
                data.m_NeedUpdate   = false;
            }
        }
    }
    
    override void OnStart(ActionData action_data)
    {
        super.OnStart(action_data);
        
        ActionPushCarData data  = ActionPushCarData.Cast(action_data);
        data.m_Car              = GetCar(action_data.m_Target);
        data.m_Origin           = data.m_Car.GetPosition();
        data.m_NeedUpdate       = true;
    }
    
    override void OnStartServer(ActionData action_data)
    {
        super.OnStartServer(action_data);
        
        ActionPushCarData data = ActionPushCarData.Cast(action_data);
 
        if (data.m_Car)
        {
            data.m_Car.SetBrake(0.0);
            data.m_Car.SetHandbrake(0.0);
            data.m_Car.SetBrakesActivateWithoutDriver(false);
        }
        
        data.m_PushDirection = -1;
        if (GetDirectionDot(data.m_Car, data.m_Player) > 0)
            data.m_PushDirection = 1;
        
    }
    
    override void OnEndServer(ActionData action_data)
    {
        super.OnEndServer(action_data);
        
        ActionPushCarData data = ActionPushCarData.Cast(action_data);
        if (data.m_Car)
            data.m_Car.SetBrakesActivateWithoutDriver(true);
    }
    
    override void OnEndInput(ActionData action_data)
    {
        super.OnEndInput(action_data);
        
        ActionPushCarData data  = ActionPushCarData.Cast(action_data);
        data.m_State            = UA_CANCEL;
        data.m_EndType          = 1;
        data.m_NeedUpdate       = false;
    }
    
    override void WriteToContext(ParamsWriteContext ctx, ActionData action_data)
    {
        super.WriteToContext(ctx, action_data);
        
        ActionPushCarData data = ActionPushCarData.Cast(action_data);
        
        ctx.Write(data.m_Car);
    }
    
    override bool ReadFromContext(ParamsReadContext ctx, out ActionReciveData action_recive_data)
    {
        if (!action_recive_data)
            action_recive_data = new ActionPushCarDataReceiveData();
        
        super.ReadFromContext(ctx, action_recive_data);
        
        CarScript car;
        if (!ctx.Read(car))
            return false;
        
        ActionPushCarDataReceiveData receiveData    = ActionPushCarDataReceiveData.Cast(action_recive_data);
        receiveData.m_Car                           = car;
        
        return true;
    }
    
    override void HandleReciveData(ActionReciveData action_recive_data, ActionData action_data)
    {
        super.HandleReciveData(action_recive_data, action_data);
 
        ActionPushCarDataReceiveData receiveData    = ActionPushCarDataReceiveData.Cast(action_recive_data);
        receiveData.m_Car                           = receiveData.m_Car;
    }
    
    private float GetDirectionDot(Object target, EntityAI player)
    {
        return vector.Dot(target.GetDirection(), player.GetDirection());
    }
    
    private CarScript GetCar(ActionTarget target)
    {
        if (target.IsProxy())
            return CarScript.Cast(target.GetParent());
        
        return CarScript.Cast(target.GetObject());
    }
}