ActionFishingNew.c

Go to the documentation of this file.

class FishingActionData : ActionData
{
  const float FISHING_SUCCESS = 0.2;
  const float FISHING_BAIT_LOSS = 0.02;
  const float FISHING_HOOK_LOSS = 0.015;
  const float FISHING_DAMAGE = 1.5;
  const float FISHING_GARBAGE_CHANCE = 0.2;
 
  bool m_IsSurfaceSea;
  bool m_IsBaitAnEmptyHook;
  int m_FishingResult = -1;
  float m_RodQualityModifier = 0;
  ItemBase m_Bait;
 
  void InitBait(ItemBase item)
  {
    m_Bait = item;
    m_IsBaitAnEmptyHook = !m_Bait.ConfigIsExisting("hookType");
  }
 
  bool IsBaitEmptyHook()
  {
    return m_IsBaitAnEmptyHook;
  }
}
 
class ActionFishingNewCB : ActionContinuousBaseCB
{
  FishingActionData m_ActionDataFishing;
  ref array<string> m_JunkTypes = {
    "Wellies_Black",
    "Wellies_Brown",
    "Wellies_Green",
    "Wellies_Grey",
    "Pot"
  };
 
  override void CreateActionComponent()
  {
    EnableStateChangeCallback();
    m_ActionData.m_ActionComponent = new CAContinuousRepeatFishing(3.0);
  }
 
  override void EndActionComponent()
  {
    m_ActionDataFishing = FishingActionData.Cast(m_ActionData);
 
    if (!m_ActionDataFishing)
    {
      super.EndActionComponent();
      return;
    }
 
    if (m_ActionDataFishing.m_State == UA_FINISHED)
    {
      if (m_ActionDataFishing.m_FishingResult == 1)
        SetCommand(DayZPlayerConstants.CMD_ACTIONINT_END);
      else if (m_ActionDataFishing.m_FishingResult == 0)
        SetCommand(DayZPlayerConstants.CMD_ACTIONINT_FINISH);
    }
    else if (m_ActionDataFishing.m_State == UA_CANCEL)
    {
      ActionContinuousBase action = ActionContinuousBase.Cast(m_ActionDataFishing.m_Action);
      if (action.HasAlternativeInterrupt())
        SetCommand(DayZPlayerConstants.CMD_ACTIONINT_FINISH);
      else
        SetCommand(DayZPlayerConstants.CMD_ACTIONINT_END);
 
      m_Canceled = true;
      return;
    }
    else
    {
      if (m_ActionDataFishing.m_FishingResult == 1)
        SetCommand(DayZPlayerConstants.CMD_ACTIONINT_END);
      else if (m_ActionDataFishing.m_FishingResult == 0)
        SetCommand(DayZPlayerConstants.CMD_ACTIONINT_FINISH);
    }
 
    m_ActionDataFishing.m_State = UA_FINISHED;
  }
 
  void HandleFishingResultSuccess()
  {
    if (!GetGame().IsMultiplayer() || GetGame().IsServer())
    {
      ItemBase fish;
 
      if (!m_ActionDataFishing.m_Bait)
        m_ActionDataFishing.InitBait(ItemBase.Cast(m_ActionDataFishing.m_MainItem.FindAttachmentBySlotName("Hook")));
 
      if (!m_ActionDataFishing.IsBaitEmptyHook())
      {
        m_ActionDataFishing.m_Bait.AddHealth(-m_ActionDataFishing.FISHING_DAMAGE);
        MiscGameplayFunctions.TurnItemIntoItem(m_ActionDataFishing.m_Bait, m_ActionDataFishing.m_Bait.ConfigGetString("hookType"), m_ActionDataFishing.m_Player);
      }
      else
        m_ActionDataFishing.m_Bait.AddHealth(-m_ActionDataFishing.FISHING_DAMAGE);
 
      float rnd = Math.RandomFloatInclusive(0.0, 1.0);
      if (rnd > m_ActionDataFishing.FISHING_GARBAGE_CHANCE)
      {
        if (m_ActionDataFishing.m_IsSurfaceSea)
          fish = ItemBase.Cast(GetGame().CreateObjectEx("Mackerel", m_ActionDataFishing.m_Player.GetPosition(), ECE_PLACE_ON_SURFACE));
        else
          fish = ItemBase.Cast(GetGame().CreateObjectEx("Carp", m_ActionDataFishing.m_Player.GetPosition(), ECE_PLACE_ON_SURFACE));
      }
      else
      {
        if (!m_ActionDataFishing.m_IsSurfaceSea)
        {
          string junkType = m_JunkTypes.Get(Math.RandomInt(0, m_JunkTypes.Count()));
          fish = ItemBase.Cast(GetGame().CreateObjectEx(junkType, m_ActionDataFishing.m_Player.GetPosition(), ECE_PLACE_ON_SURFACE));
          fish.SetHealth("", "Health", fish.GetMaxHealth("", "Health") * 0.1);
        }
      }
 
      if (fish)
      {
        //Print("---Caught something: " + fish + "---");
        fish.SetWet(0.3);
        if (fish.HasQuantity())
        {
          float coef = Math.RandomFloatInclusive(0.5, 1.0);
          float item_quantity = fish.GetQuantityMax() * coef;
          item_quantity = Math.Round(item_quantity);
          fish.SetQuantity(item_quantity);
          fish.InsertAgent(eAgents.CHOLERA);
        }
      }
 
      m_ActionDataFishing.m_MainItem.AddHealth(-m_ActionDataFishing.FISHING_DAMAGE);
    }
  }
 
  void HandleFishingResultFailure()
  {
    if (!GetGame().IsMultiplayer() || GetGame().IsServer())
    {
      if (!m_ActionDataFishing.m_Bait)
        m_ActionDataFishing.InitBait(ItemBase.Cast(m_ActionDataFishing.m_MainItem.FindAttachmentBySlotName("Hook")));
 
      if (Math.RandomFloatInclusive(0.0, 1.0) > m_ActionDataFishing.FISHING_HOOK_LOSS) //loss of worm only
      {
        if (!m_ActionDataFishing.IsBaitEmptyHook())
        {
          m_ActionDataFishing.m_Bait.AddHealth(-m_ActionDataFishing.FISHING_DAMAGE);
          MiscGameplayFunctions.TurnItemIntoItem(m_ActionDataFishing.m_Bait, m_ActionDataFishing.m_Bait.ConfigGetString("hookType"), m_ActionDataFishing.m_Player);
        }
      }
      else //loss of the entire hook
        m_ActionDataFishing.m_Bait.Delete();
 
      m_ActionDataFishing.m_MainItem.AddHealth(-m_ActionDataFishing.FISHING_DAMAGE);
    }
  }
 
  override void OnStateChange(int pOldState, int pCurrentState)
  {
    if (pCurrentState == STATE_NONE && m_ActionDataFishing)
    {
      if (m_ActionDataFishing.m_FishingResult == 1 && pOldState == STATE_LOOP_END)
        HandleFishingResultSuccess();
      else if (m_ActionDataFishing.m_FishingResult == 0 && pOldState == STATE_LOOP_END2)
        HandleFishingResultFailure();
    }
  }
};
 
class ActionFishingNew: ActionContinuousBase
{
  private const string ALLOWED_WATER_SURFACES = string.Format("%1|%2", UAWaterType.SEA, UAWaterType.FRESH);
 
  void ActionFishingNew()
  {
    m_CallbackClass = ActionFishingNewCB;
    m_SpecialtyWeight = UASoftSkillsWeight.PRECISE_MEDIUM;
    m_CommandUID = DayZPlayerConstants.CMD_ACTIONFB_FISHING;
    m_FullBody = true;
    m_StanceMask = DayZPlayerConstants.STANCEMASK_CROUCH;
    m_Text = "#start_fishing";
  }
 
  override void CreateConditionComponents()
  {
    m_ConditionItem = new CCINonRuined();
    m_ConditionTarget = new CCTWaterSurface(UAMaxDistances.BASEBUILDING, ALLOWED_WATER_SURFACES);
  }
 
  override bool HasTarget()
  {
    return true;
  }
 
  override bool HasAlternativeInterrupt()
  {
    return true;
  }
 
  override bool ActionCondition(PlayerBase player, ActionTarget target, ItemBase item)
  {
    ItemBase bait;
    FishingRod_Base_New rod = FishingRod_Base_New.Cast(item);
 
    if (rod)
      bait = ItemBase.Cast(rod.FindAttachmentBySlotName("Hook"));
 
    if (bait && !bait.IsRuined())
      return true;
 
    return false;
  }
 
  override ActionData CreateActionData()
  {
    FishingActionData actionData = new FishingActionData();
    return actionData;
  }
 
  override bool SetupAction(PlayerBase player, ActionTarget target, ItemBase item, out ActionData action_data, Param extra_data = null)
  {
    if (super.SetupAction(player, target, item, action_data, extra_data))
    {
      vector cursorPosition = action_data.m_Target.GetCursorHitPos();
      if (cursorPosition == vector.Zero)
        cursorPosition = player.GetPosition();
 
      if (GetGame().SurfaceIsSea(cursorPosition[0], cursorPosition[2]))
        FishingActionData.Cast(action_data).m_IsSurfaceSea = true;
 
      FishingRod_Base_New rod = FishingRod_Base_New.Cast(action_data.m_MainItem);
      if (rod)
      {
        FishingActionData.Cast(action_data).m_RodQualityModifier = rod.GetFishingEffectivityBonus();
        FishingActionData.Cast(action_data).InitBait(ItemBase.Cast(action_data.m_MainItem.FindAttachmentBySlotName("Hook")));
      }
      return true;
    }
    return false;
  }
 
  override void OnFinishProgressServer(ActionData action_data)
  {
    action_data.m_Callback.InternalCommand(DayZPlayerConstants.CMD_ACTIONINT_ACTION);
    FishingActionData.Cast(action_data).m_FishingResult = EvaluateFishingResult(action_data);
  }
 
  override void OnFinishProgressClient(ActionData action_data)
  {
    action_data.m_Callback.InternalCommand(DayZPlayerConstants.CMD_ACTIONINT_ACTION);
    FishingActionData.Cast(action_data).m_FishingResult = EvaluateFishingResult(action_data);
  }
 
  override void OnStartClient(ActionData action_data)
  {
    FishingRod_Base_New rod = FishingRod_Base_New.Cast(action_data.m_MainItem);
    rod.AnimateFishingRod(true);
  }
  override void OnStartServer(ActionData action_data)
  {
    FishingRod_Base_New rod = FishingRod_Base_New.Cast(action_data.m_MainItem);
    rod.AnimateFishingRod(true);
  }
 
  override void OnEndClient(ActionData action_data)
  {
    FishingRod_Base_New rod = FishingRod_Base_New.Cast(action_data.m_MainItem);
    rod.AnimateFishingRod(false);
  }
  override void OnEndServer(ActionData action_data)
  {
    FishingRod_Base_New rod = FishingRod_Base_New.Cast(action_data.m_MainItem);
    rod.AnimateFishingRod(false);
  }
 
  override void WriteToContext(ParamsWriteContext ctx, ActionData action_data)
  {
    super.WriteToContext(ctx, action_data);
 
    if (HasTarget())
      ctx.Write(action_data.m_Target.GetCursorHitPos());
  }
 
  override bool ReadFromContext(ParamsReadContext ctx, out ActionReciveData action_recive_data)
  {
    super.ReadFromContext(ctx, action_recive_data);
 
    if (HasTarget())
    {
      vector cursor_position;
      if (!ctx.Read(cursor_position))
        return false;
 
      action_recive_data.m_Target.SetCursorHitPos(cursor_position);
    }
    return true;
  }
 
  int EvaluateFishingResult(ActionData action_data)
  {
    if (action_data.m_Player.IsQuickFishing())
      return 1;
 
    FishingActionData fad = FishingActionData.Cast(action_data);
    float rnd = fad.m_Player.GetRandomGeneratorSyncManager().GetRandom01(RandomGeneratorSyncUsage.RGSGeneric);
    float daytimeModifier = 1;
    float hookModifier = 1;
    float chance;
 
    daytimeModifier = GetGame().GetDayTime();
    if ((daytimeModifier > 18 && daytimeModifier < 22) || (daytimeModifier > 5 && daytimeModifier < 9))
      daytimeModifier = 1;
    else
      daytimeModifier = 0.5;
 
    //fishing with an empty hook
    if (fad.IsBaitEmptyHook())
      hookModifier = 0.05;
 
    chance = 1 - (((fad.FISHING_SUCCESS * daytimeModifier) + fad.m_RodQualityModifier)) * hookModifier;
 
    if (rnd > chance)
      return 1;
    else if (rnd < fad.FISHING_BAIT_LOSS && !fad.IsBaitEmptyHook()) // restricts the loss of an empty hook (low chance is enough)
      return 0;
 
    return -1;
  }
}