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());
  }
}