GardenBase.c

Go to the documentation of this file.

class GardenBase extends ItemBase //BuildingSuper
{
  // Paths to slot textures. Slots can have multiple states, so multiple textures must be generated
  static const string SLOT_TEXTURE_DIGGED_WET_LIME = "dz\\gear\\cultivation\\data\\soil_digged_wet_lime_CO.paa";
  static const string SLOT_TEXTURE_DIGGED_WET_PLANT = "dz\\gear\\cultivation\\data\\soil_digged_wet_plant_CO.paa";
 
  // Wet/dry material
  static const string SLOT_MATERIAL_WET = "dz\\gear\\cultivation\\data\\soil_cultivated_wet.rvmat";
  static const string SLOT_MATERIAL_DRY = "dz\\gear\\cultivation\\data\\soil_cultivated.rvmat";
 
  static const string SLOT_MATERIAL_LIMED_WET = "dz\\gear\\cultivation\\data\\soil_cultivated_limed_wet.rvmat";
  static const string SLOT_MATERIAL_LIMED_DRY = "dz\\gear\\cultivation\\data\\soil_cultivated_limed.rvmat";
  static const string SLOT_MATERIAL_COMPOST_WET = "dz\\gear\\cultivation\\data\\soil_cultivated_compost_wet.rvmat";
  static const string SLOT_MATERIAL_COMPOST_DRY = "dz\\gear\\cultivation\\data\\soil_cultivated_compost.rvmat";
 
  // slot names -> MUST BE LOWERCASE
  private static const string SLOT_SELECTION_DIGGED_PREFIX = "seedbase_";
  private static const string SLOT_SELECTION_COVERED_PREFIX = "slotCovered_";
  private static const string SLOT_MEMORY_POINT_PREFIX = "slot_";
  private static const string SLOT_SEEDBASE_PREFIX = "seedbase_";
 
 
  private static const int CHECK_RAIN_INTERVAL = 15;
 
  protected ref array<ref Slot> m_Slots;
  protected int m_SlotFertilityState = 0; //Used to store fertility state of all slots
  protected int m_SlotWateredState = 0; //Used to store fertility state of all slots
  protected int m_MaxWateredStateVal = 0; //Used to store fertility state of all slots
  protected float m_DefaultFertility = 1;
  ref Timer m_CheckRainTimer;
 
  private static ref map<string, string> m_map_slots; // For the 'attachment slot -> plant slot' conversion. It is possible that this will be removed later.
 
  void GardenBase()
  {
    RegisterNetSyncVariableInt("m_SlotFertilityState");
    RegisterNetSyncVariableInt("m_SlotWateredState");
 
    m_map_slots = new map<string, string>;
 
    SetEventMask(EntityEvent.INIT); // Enable EOnInit event
 
    // Prepare m_map_slots
    for (int i = 1; i <= GetGardenSlotsCount() ; ++i)
    {
      // m_map_slots is supposed to be: <input, output>
      string input = SLOT_SEEDBASE_PREFIX + i.ToString();
      string output = SLOT_MEMORY_POINT_PREFIX;
 
      if (i < 10)
        output = output + "0"; // Example: '1' changes to '01'
 
      output = output + i.ToString();
 
      m_map_slots.Set(input, output);
    }
 
    if (GetGame().IsServer())
      CheckRainStart();
 
    InitializeSlots();
 
    SetMaxWaterStateVal();
  }
 
  override void OnVariablesSynchronized()
  {
    super.OnVariablesSynchronized();
 
    SyncSlots();
  }
 
  override bool HasProxyParts()
  {
    return true;
  }
 
  override int GetHideIconMask()
  {
    return EInventoryIconVisibility.HIDE_VICINITY;
  }
 
  void SetBaseFertility(float value)
  {
    m_DefaultFertility = value;
  }
 
  float GetBaseFertility()
  {
    return m_DefaultFertility;
  }
 
  override void EOnInit(IEntity other, int extra)
  {
    CheckRainTick();
    UpdateTexturesOnAllSlots();
  }
 
  void InitializeSlots()
  {
    m_Slots = new array<ref Slot>;
    int slots_count = GetGardenSlotsCount();
 
    for (int i = 0; i < slots_count; i++)
    {
      Slot slot = new Slot(GetBaseFertility());
      slot.SetSlotIndex(i);
      int i1 = i + 1;
      string name = "SeedBase_" + i1;
      int slot_id = InventorySlots.GetSlotIdFromString(name);
      slot.SetSlotId(slot_id);
      slot.SetGarden(this);
      slot.m_State = Slot.STATE_DIGGED;
      m_Slots.Insert(slot);
    }
  }
 
  void SetMaxWaterStateVal()
  {
    int state = 0;
 
    for (int i = 0; i < m_Slots.Count(); i++)
      state += 1 * Math.Pow(2, i);
 
    m_MaxWateredStateVal = state;
  }
 
  int GetMaxWaterStateVal()
  {
    return m_MaxWateredStateVal;
  }
 
  void UpdateTexturesOnAllSlots()
  {
    int slots_count = GetGardenSlotsCount();
 
    for (int i = 0; i < slots_count; i++)
      UpdateSlotTexture(i);
  }
 
  override bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    if (version <= 118)
      return true;
 
    if (!super.OnStoreLoad(ctx, version))
      return false;
 
    if (version < 102)
    {
      float some_value;
      ctx.Read(some_value); // compatibility check
    }
 
    int slots_count = GetGardenSlotsCount();
 
    for (int i = 0; i < slots_count; i++)
    {
      Slot slot = m_Slots.Get(i);
 
      if (!slot.OnStoreLoadCustom(ctx, version))
        return false;
 
      //Slot textures will be updated after store load
      //UpdateSlotTexture( i );
    }
 
    if (version >= 119)
      ctx.Read(m_SlotFertilityState);
 
    if (version >= 120)
      ctx.Read(m_SlotWateredState);
 
    return true;
  }
 
  override void AfterStoreLoad()
  {
    super.AfterStoreLoad();
  }
 
  override void EEOnAfterLoad()
  {
    GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).CallLater(SyncSlots, 500, false, this);
    super.EEOnAfterLoad();
  }
 
  void SyncSlots()
  {
    for (int i = 0; i < GetGardenSlotsCount(); i++)
    {
      // Read relevant bit
      int fertilityState = (m_SlotFertilityState >> i) & 1;
      m_Slots[i].SetFertilityState(fertilityState);
 
      int wateredState = (m_SlotWateredState >> i) & 1;
      m_Slots[i].SetWateredState(wateredState);
 
      if (fertilityState == eFertlityState.NONE)
      {
        m_Slots[i].SetFertilityType("");
        m_Slots[i].SetFertilizerQuantity(0);
      }
 
      if (wateredState == eWateredState.DRY)
        m_Slots[i].SetWater(0);
 
      UpdateSlotTexture(i);
    }
 
    if (GetGame().IsServer())
      SetSynchDirty();
  }
 
  override void OnStoreSave(ParamsWriteContext ctx)
  {
    super.OnStoreSave(ctx);
 
    int slots_count = GetGardenSlotsCount();
 
    for (int i = 0; i < slots_count; i++)
    {
      Slot slot = m_Slots.Get(i);
 
      slot.OnStoreSaveCustom(ctx);
    }
 
    ctx.Write(m_SlotFertilityState);
 
    ctx.Write(m_SlotWateredState);
  }
 
  void PrintSlots()
  {
    Debug.Log("PRINT ALL SLOTS FROM...");
    Debug.Log("" + this);
    int slots = GetInventory().GetAttachmentSlotsCount();
    Debug.Log("Nb Slots : " + slots);
 
    for (int i = 0; i < slots ; i++)
    {
      Slot slot = m_Slots.Get(i);
      Debug.Log("i : " + i);
      Debug.Log("Slot : " + slot);
 
      float slot_fertility = slot.GetFertility();
      float slot_fertility_usage = slot.GetFertilityMax();
      string slot_fertility_type = slot.GetFertilityType();
      float slot_water = slot.GetWater();
      float slot_water_usage = slot.GetWaterUsage();
      ItemBase slot_seed = slot.GetSeed();
      ItemBase slot_plant = slot.GetPlant();
      float slot_state = slot.GetState();
      float slot_slot_Index = slot.GetSlotIndex();
      float slot_slot_ID = slot.GetSlotId();
      int slot_wateredState = slot.GetWateredState();
      int slot_FertilityState = slot.GetFertilityState();
 
      Debug.Log("Fertility : " + slot_fertility);
      Debug.Log("Fertility Usage : " + slot_fertility_usage);
      Debug.Log("Fertility Type : " + slot_fertility_type);
      Debug.Log("Fertility State : " + slot_FertilityState);
      Debug.Log("Water : " + slot_water);
      Debug.Log("Water Usage : " + slot_water_usage);
      Debug.Log("Watered State : " + slot_wateredState);
      Debug.Log("Seed : " + slot_seed);
      Debug.Log("Plant : " + slot_plant);
      Debug.Log("State : " + slot_state);
      Debug.Log("Slot Index : " + slot_slot_Index);
      Debug.Log("Slot ID : " + slot_slot_ID);
      Debug.Log("///////////////////////////");
    }
 
    Debug.Log("END OF ALL SLOTS FOR...");
    Debug.Log("" + this);
  }
 
  override bool CanPutInCargo(EntityAI parent)
  {
    if (!super.CanPutInCargo(parent)) return false;
    return false;
  }
 
  override bool CanPutIntoHands(EntityAI player)
  {
    if (!super.CanPutIntoHands(parent))
      return false;
    return false;
  }
 
  override bool CanRemoveFromHands(EntityAI player)
  {
    return false;
  }
 
  int GetGardenSlotsCount()
  {
    return 0;
  }
 
  bool CanPlantSeed(string selection_component)
  {
    Slot slot = GetSlotBySelection(selection_component);
 
    if (slot != NULL && slot.m_State == Slot.STATE_DIGGED)
      return true;
    else
      return false;
  }
 
  // Converts attachment slot name into plant slot name. Example: 'seedbase_1' -> 'component02'
  string ConvertAttSlotToPlantSlot(string attach_slot)
  {
    // Give result
    if (m_map_slots.Contains(attach_slot))
    {
      string return_value = m_map_slots.Get(attach_slot);
      return return_value;
    }
 
    return "";
  }
 
  override void EEItemAttached(EntityAI item, string slot_name)
  {
    super.EEItemAttached(item, slot_name);
 
    string path = string.Format("CfgVehicles %1 Horticulture PlantType", item.GetType());
    bool IsItemSeed = GetGame().ConfigIsExisting(path); // Is this item a seed?
 
    int slot_id = InventorySlots.GetSlotIdFromString(slot_name);
 
    if (IsItemSeed)
    {
      string converted_slot_name;
 
      vector pos = GetPosition();
      int index = GetSlotIndexByAttachmentSlot(slot_name);
 
      if (index < 10)
        converted_slot_name = SLOT_MEMORY_POINT_PREFIX + "0" + index.ToString();
      else
        converted_slot_name = SLOT_MEMORY_POINT_PREFIX + index.ToString();
 
      PlantSeed(ItemBase.Cast(item), converted_slot_name);
    }
    else if (g_Game.IsClient())
    {
      Slot slot = GetSlotByIndex(GetSlotIndexByAttachmentSlot(slot_name) - 1);
      if (slot)
      {
        slot.SetPlant(PlantBase.Cast(item));
        slot.m_State = Slot.STATE_PLANTED;
      }
    }
  }
 
  override void EEItemDetached(EntityAI item, string slot_name)
  {
    super.EEItemDetached(item, slot_name);
 
    slot_name.ToLower();
 
    string path = string.Format("CfgVehicles %1 Horticulture PlantType", item.GetType());
    bool IsItemSeed = GetGame().ConfigIsExisting(path); // Is this item a seed?
 
    string converted_slot_name = ConvertAttSlotToPlantSlot(slot_name);
    Slot slot = GetSlotBySelection(converted_slot_name);
 
    if (slot)
    {
      if (IsItemSeed)
        slot.SetSeed(NULL);
 
      slot.SetState(Slot.STATE_DIGGED);
    }
  }
 
  // Plants the seed into slot (selection_component)
  void PlantSeed(ItemBase seed, string selection_component)
  {
    int slot_index = GetSlotIndexBySelection(selection_component);
 
    if (slot_index != -1)
    {
      PluginHorticulture module_horticulture = PluginHorticulture.Cast(GetPlugin(PluginHorticulture));
      string plant_type = module_horticulture.GetPlantType(seed);
 
      Slot slot = m_Slots.Get(slot_index);
      slot.SetState(Slot.STATE_PLANTED);
      slot.m_PlantType = plant_type;
      slot.SetSeed(seed);
 
      if (!slot.NeedsWater())
      {
        seed.LockToParent();
        //Take some small amount of time before making a plant out of seeds
        Timer growthTimer = NULL;
        growthTimer = new Timer(CALL_CATEGORY_SYSTEM);
        Param createPlantParam = new Param1<Slot>(slot);
        growthTimer.Run(0.1, this, "CreatePlant", createPlantParam, false); //Use a const for timer delay
      }
    }
  }
 
  // Creates a plant
  void CreatePlant(Slot slot)
  {
    if (g_Game.IsServer())
    {
      ItemBase seed = slot.GetSeed();
      seed.UnlockFromParent();
      GetGame().ObjectDelete(seed);
 
      PlantBase plant = PlantBase.Cast(GetInventory().CreateAttachmentEx(slot.m_PlantType, slot.GetSlotId()));
 
      int slot_index = slot.GetSlotIndex();
      slot.SetPlant(plant);
      plant.Init(this, slot.GetFertility(), slot.m_HarvestingEfficiency, slot.GetWater());
      //ShowSelection(SLOT_SELECTION_COVERED_PREFIX + (slot_index + 1).ToStringLen(2));
 
      plant.LockToParent();
    }
  }
 
  void Fertilize(PlayerBase player, ItemBase item, float consumed_quantity, string selection_component)
  {
    Slot slot = GetSlotBySelection(selection_component);
 
    if (slot != NULL)
    {
      string item_type = item.GetType();
 
      if (slot.GetFertilityType() == "" || slot.GetFertilityType() == item_type)
      {
        slot.SetFertilityType(item_type);
 
        float add_energy_to_slot = GetGame().ConfigGetFloat(string.Format("cfgVehicles %1 Horticulture AddEnergyToSlot", item_type));
        slot.m_FertilizerUsage = GetGame().ConfigGetFloat(string.Format("cfgVehicles %1 Horticulture ConsumedQuantity", item_type));
 
        float coef = Math.Clamp(consumed_quantity / slot.m_FertilizerUsage, 0.0, 1.0);
        add_energy_to_slot = coef * add_energy_to_slot;
 
        slot.m_FertilizerQuantity += consumed_quantity;
        slot.m_Fertility += add_energy_to_slot;
 
        if (slot.GetFertilizerQuantity() >= slot.GetFertilizerQuantityMax())
        {
          int slot_index = slot.GetSlotIndex();
 
          if (slot_index > -1)
          {
            UpdateSlotTexture(slot_index);
            slot.SetFertilityState(eFertlityState.FERTILIZED);
            // Set relevant bit
            m_SlotFertilityState |= slot.GetFertilityState() << slot.GetSlotIndex();
 
            //TODO Boris: Add soft skill 2.0
            //PluginExperience module_exp = GetPlugin(PluginExperience);
            //slot.m_HarvestingEfficiency = module_exp.GetExpParamNumber(player, PluginExperience.EXP_FARMER_FERTILIZATION, "efficiency");
          }
        }
      }
      else
      {
        slot.SetFertilizerQuantity(0);
        slot.SetFertilityType("");
        slot.SetFertilityState(eFertlityState.NONE);
      }
      SetSynchDirty();
    }
  }
 
  bool IsCorrectFertilizer(ItemBase item, string selection_component)
  {
    Slot slot = GetSlotBySelection(selection_component);
 
    if (slot != NULL)
    {
      string item_type = item.GetType();
 
      if (slot.GetFertilityType() == "" || slot.GetFertilityType() == item_type)
        return true;
    }
 
    return false;
  }
 
  bool NeedsFertilization(string selection_component)
  {
    Slot slot = GetSlotBySelection(selection_component);
 
    if (slot)
    {
      if (slot.GetFertilityState() == eFertlityState.NONE)
        return true;
    }
 
    return false;
  }
 
  void SlotWaterStateUpdate(Slot slot)
  {
    // Set relevant bit
    m_SlotWateredState |= slot.GetWateredState() << slot.GetSlotIndex();
    SetSynchDirty();
  }
 
  void UpdateSlotTexture(int slot_index)
  {
    // TO DO: Fix DAYZ-30633 here!
    Slot slot = m_Slots.Get(slot_index);
 
    // Show / Hide selections according to DIGGED or COVERED states.
 
    if (slot.IsDigged() || slot.IsPlanted())
    {
      string str_hide = SLOT_SELECTION_COVERED_PREFIX + (slot_index + 1).ToStringLen(2);
      string str_show = SLOT_SELECTION_DIGGED_PREFIX + (slot_index + 1).ToStringLen(1);
 
      HideSelection(str_hide);
      ShowSelection(str_show);
    }
 
    if (slot.GetFertilityType() != "")
      SetSlotTextureFertilized(slot_index, slot.GetFertilityType());
    else
      SetSlotTextureDigged(slot_index);
  }
 
  void SetSlotTextureDigged(int slot_index)
  {
    TStringArray textures = GetHiddenSelectionsTextures();
 
    string str_digged = SLOT_SELECTION_DIGGED_PREFIX + (slot_index + 1).ToStringLen(1);
 
    ShowSelection(str_digged);
    string texture = textures.Get(0);
    SetObjectTexture(slot_index, texture);
 
    Slot slot = m_Slots.Get(slot_index);
 
    if (slot.GetWateredState() == 0)
    {
      // Set dry material
      SetObjectMaterial(slot_index, SLOT_MATERIAL_DRY);
    }
    else
    {
      // Set wet material
      SetObjectMaterial(slot_index, SLOT_MATERIAL_WET);
    }
  }
 
  void SetSlotTextureFertilized(int slot_index, string item_type)
  {
    TStringArray textures = GetHiddenSelectionsTextures();
 
    int tex_id = GetGame().ConfigGetInt(string.Format("cfgVehicles %1 Horticulture TexId", item_type));
 
    string str_show = SLOT_SELECTION_DIGGED_PREFIX + (slot_index + 1).ToStringLen(2);
 
    ShowSelection(str_show);
    SetObjectTexture(slot_index, textures.Get(tex_id));
 
    Slot slot = m_Slots.Get(slot_index);
 
    int slot_index_offset = 0;
 
    // Set material according to dry / wet states
    if (slot.GetWateredState() == 0)
    {
      // Set dry material for garden lime
      if (slot.GetFertilityType() == "GardenLime")
        SetObjectMaterial(slot_index + slot_index_offset, SLOT_MATERIAL_LIMED_DRY);
      else if (slot.GetFertilityType() == "PlantMaterial")
        SetObjectMaterial(slot_index + slot_index_offset, SLOT_MATERIAL_COMPOST_DRY);
    }
    else
    {
      // Set dry material for compost
      if (slot.GetFertilityType() == "GardenLime")
        SetObjectMaterial(slot_index + slot_index_offset, SLOT_MATERIAL_LIMED_WET);
      else if (slot.GetFertilityType() == "PlantMaterial")
        SetObjectMaterial(slot_index + slot_index_offset, SLOT_MATERIAL_COMPOST_WET);
    }
  }
 
  void RemoveSlot(int index)
  {
    if (m_Slots != NULL)
    {
      Slot slot = m_Slots.Get(index);
      PlantBase plant = slot.GetPlant();
 
      if (plant)
      {
        plant.UnlockFromParent();
        plant.m_MarkForDeletion = true;
        GetGame().ObjectDelete(plant);
      }
 
      slot.Init(GetBaseFertility());
 
      // Clear relevant bit
      slot.SetFertilityState(eFertlityState.NONE);
      m_SlotFertilityState &= ~(1 << slot.GetSlotIndex());
 
      slot.SetWateredState(eWateredState.DRY);
      m_SlotWateredState &= ~(1 << slot.GetSlotIndex());
 
      SetSynchDirty();
 
      HideSelection(SLOT_SELECTION_COVERED_PREFIX + (index + 1).ToStringLen(2));
      UpdateSlotTexture(index);
    }
  }
 
  void RemoveSlotPlant(Object plant)
  {
    int index = GetSlotIndexByPlant(plant);
    if (index >= 0)
      RemoveSlot(index);
  }
 
  Slot GetSlotBySelection(string selection_component)
  {
    int slot_index = GetSlotIndexBySelection(selection_component);
 
    if (slot_index > -1)
      return m_Slots.Get(slot_index);
    else
      return NULL;
  }
 
  // Returns slot array index by selection, starting from 0 as the first one.
  int GetSlotIndexBySelection(string selection_component)
  {
    int slot_index = -1;
 
    if (m_Slots != NULL)
    {
      string selection_component_lower = selection_component;
      selection_component_lower.ToLower();
 
      int start = selection_component_lower.IndexOf(SLOT_MEMORY_POINT_PREFIX);
 
      if (start > -1)
      {
        start += SLOT_MEMORY_POINT_PREFIX.Length();
        int end = start + 2;
        int length = selection_component.Length();
 
        if (length >= end)
        {
          int length_add = length - end; // Hack-fix for inconsistent component names in p3d
          int length_from_end = 2 + length_add;
          string num_str = selection_component.Substring(start, length_from_end);
          slot_index = num_str.ToInt();
 
          slot_index = slot_index - 1;
        }
      }
    }
 
    return slot_index;
  }
 
  int GetSlotIndexByAttachmentSlot(string att_slot)
  {
    int slot_index = -1;
 
    int start = "SeedBase_".Length();
    int end = att_slot.Length();//start + 2;
    int len = end - start;
 
    string num_str = att_slot.Substring(start, len);
    slot_index = num_str.ToInt();
 
    return slot_index;
  }
 
  int GetSlotIndexByPlant(Object plant)
  {
    if (m_Slots != NULL)
    {
      for (int i = 0; i < m_Slots.Count(); i++)
      {
        PlantBase found_plant = m_Slots.Get(i).GetPlant();
 
        if (found_plant == plant)
          return i;
      }
    }
 
    return -1;
  }
 
  int GetNearestSlotIDByState(vector position, int slot_state)
  {
    float nearest_distance = 1000.0;
    int nearest_slot_index = -1;
    int slots_count = GetGardenSlotsCount();
    for (int i = 0; i < slots_count; i++)
    {
      Slot slot = m_Slots.Get(i); // Move this line by a scope higher in this function after debugging
 
      vector slot_pos = GetSlotPosition(i);
      float current_distance = vector.Distance(position, slot_pos);
 
      if (current_distance < nearest_distance)
      {
        if (slot != NULL && slot.m_State == slot_state)
        {
          nearest_distance = current_distance;
          nearest_slot_index = i;
        }
      }
    }
 
    return nearest_slot_index;
  }
 
  vector GetSlotPosition(int index)
  {
    string memory_point = SLOT_MEMORY_POINT_PREFIX + (index + 1).ToStringLen(2);
    vector pos = this.GetSelectionPositionMS(memory_point);
 
    return this.ModelToWorld(pos);
  }
 
  void CheckRainStart()
  {
    if (!m_CheckRainTimer)
      m_CheckRainTimer = new Timer(CALL_CATEGORY_SYSTEM);
 
    m_CheckRainTimer.Run(CHECK_RAIN_INTERVAL, this, "CheckRainTick", NULL, true);
  }
 
  void CheckRainTick()
  {
    float rain_intensity = GetGame().GetWeather().GetRain().GetActual();
 
    float wetness = rain_intensity * 20 * CHECK_RAIN_INTERVAL;
 
    if (rain_intensity > 1 || rain_intensity < 0)
      wetness = 0; // hackfix for weird values returned by weather system
 
    if (wetness == 0)
      wetness = -0.1 * CHECK_RAIN_INTERVAL;
 
    int slots_count = GetGardenSlotsCount();
 
    if (rain_intensity > 0)
    {
      WaterAllSlots();
      SetSynchDirty();
    }
 
    for (int i = 0; i < slots_count; i++)
    {
      if (m_Slots)
      {
        Slot slot = m_Slots.Get(i);
 
        if (slot)
          slot.GiveWater(wetness * Math.RandomFloat01());
      }
    }
  }
 
  //Used to update
  void WaterAllSlots()
  {
    int state = 0;
 
    for (int i = 0; i < m_Slots.Count(); i++)
      state += 1 * Math.Pow(2, i);
 
    SetSlotWateredState(state);
  }
 
  array<ref Slot> GetSlots()
  {
    return m_Slots;
  }
 
  Slot GetSlotByIndex(int index)
  {
    return m_Slots.Get(index);
  }
 
  int GetSlotWateredState()
  {
    return m_SlotWateredState;
  }
 
  void SetSlotWateredState(int newState)
  {
    m_SlotWateredState = newState;
  }
 
  override void SetActions()
  {
    AddAction(ActionHarvestCrops);
    AddAction(ActionRemovePlant);
    AddAction(ActionRemoveSeed);
  }
}