PlantBase.c

Go to the documentation of this file.

class PlantBase extends ItemBase
{
  // Plant states
  static const int STATE_DRY = 0;
  static const int STATE_GROWING = 1;
  static const int STATE_MATURE = 2;
  static const int STATE_SPOILED = 3;
 
  private float m_SprayUsage; // How much spray is needed to stop infestation of plant
 
  private float m_InfestationChance;
 
  private int m_GrowthStagesCount;
  private int m_CropsCount;
  private bool m_HasCrops;
  private string m_CropsType;
  private float m_PlantMaterialMultiplier;
 
  private int m_PlantState;
  private int m_PlantStateIndex;
  private float m_CurrentPlantMaterialQuantity;
 
  private bool m_IsInfested;
  private float m_SprayQuantity;
  bool m_MarkForDeletion = false;
 
  int m_DeleteDryPlantTime; // For how long in seconds can an unwatered plant exist before it disappears
  int m_SpoiledRemoveTime; // For how long in seconds a spoiled plant will exist
  int m_FullMaturityTime; // How much time needs plant to be full grown in seconds
  int m_SpoilAfterFullMaturityTime; // How long in seconds it takes for plant to be spoiled after it is full grown
  int m_StateChangeTime; // For how long in seconds will plant stay in one state before its going to next state
 
  ref Timer m_GrowthTimer = NULL;
  ref Timer m_InfestationTimer = NULL;
  ref Timer m_SpoilAfterFullMaturityTimer = NULL;
  ref Timer m_SpoiledRemoveTimer = NULL;
  ref Timer m_DeleteDryPlantTimer = NULL;
 
  private GardenBase m_GardenBase = NULL;
  private ref Slot m_Slot = NULL;
 
  private PluginHorticulture m_ModuleHorticulture;
 
  private const float SPOIL_AFTER_MATURITY_TIME = 14400; //The time it takes for a fully grown plant to spoil, in seconds
 
  void PlantBase()
  {
    m_ModuleHorticulture = PluginHorticulture.Cast(GetPlugin(PluginHorticulture));
 
    m_SprayUsage = 5;
    m_DeleteDryPlantTime = (60 * 10) + Math.RandomInt(0, 60 * 2);
    m_SpoiledRemoveTime = (60 * 20) + Math.RandomInt(0, 60 * 5);
 
    //Must be between 0 and 1
    m_InfestationChance = 0.2; // Temporarily disabled until its fixed. Infestation is not visualy persistent over server restarts and m_SpoiledRemoveTimer crashes when it's meant to delete the plant.
 
    string plant_type = this.GetType();
    m_GrowthStagesCount = GetGame().ConfigGetInt("cfgVehicles " + plant_type + " Horticulture GrowthStagesCount");
    m_CropsCount = GetGame().ConfigGetInt("cfgVehicles " + plant_type + " Horticulture CropsCount");
    GetGame().ConfigGetText("cfgVehicles " + plant_type + " Horticulture CropsType", m_CropsType);
 
    m_PlantStateIndex = -1;
    m_CurrentPlantMaterialQuantity = 0;
    m_IsInfested = false;
    m_SprayQuantity = 0.0;
    m_HasCrops = true;
 
    SetTakeable(false);
 
 
    RegisterNetSyncVariableBool("m_HasCrops");
    RegisterNetSyncVariableInt("m_PlantState");
    RegisterNetSyncVariableInt("m_PlantStateIndex");
  }
 
  void ~PlantBase()
  {
    if (!m_MarkForDeletion)
      DestroyPlant();
  }
 
  void Init(GardenBase garden_base, float fertility, float harvesting_efficiency, float water)
  {
    m_GardenBase = garden_base;
 
    m_FullMaturityTime += Math.RandomInt(-60, 180);
    float divided = /*(float) ((60 * 5) + Math.RandomInt(0, 60 * 1)) / fertility;*/ m_FullMaturityTime;
 
    //divided = (float)((60 * 30) + Math.RandomInt(0, 60 * 30)) * fertility;
    m_SpoilAfterFullMaturityTime = SPOIL_AFTER_MATURITY_TIME; //divided;
 
    divided = (float)((float)m_FullMaturityTime / ((float)m_GrowthStagesCount - 2.0));
    m_StateChangeTime = divided;
 
    float count = m_CropsCount * fertility * harvesting_efficiency;
    m_CropsCount = (int)Math.Ceil(count);
 
    m_PlantMaterialMultiplier = 0.1 * harvesting_efficiency;
 
    float rain_intensity = GetGame().GetWeather().GetRain().GetActual();
    if (rain_intensity > 0.0)
      CheckWater();
    else
    {
      CheckWater();
 
      if (NeedsWater())
      {
        SetPlantState(STATE_DRY);
 
        if (GetGame().IsServer())
        {
          m_DeleteDryPlantTimer = new Timer(CALL_CATEGORY_SYSTEM);
          m_DeleteDryPlantTimer.Run(m_DeleteDryPlantTime, this, "DeleteDryPlantTick", NULL, false);
        }
      }
    }
  }
 
 
  override bool OnStoreLoad(ParamsReadContext ctx, int version)
  {
    if (!super.OnStoreLoad(ctx, version))
      return false;
 
    //Print("Plant - OnStoreLoad - ");
 
    GardenBase garden = GardenBase.Cast(GetHierarchyParent());
    //Print(garden);
 
    int slot_index = -1;
    ctx.Read(slot_index);
 
    //Print(slot_index);
 
    Slot slot = garden.GetSlotByIndex(slot_index);
    //Print(slot);
 
    SetSlot(slot);
 
    if (!OnStoreLoadCustom(ctx, version))
      return false;
 
    return true;
  }
 
  override void OnStoreSave(ParamsWriteContext ctx)
  {
    super.OnStoreSave(ctx);
 
    Slot slot = GetSlot();
 
    if (slot)
    {
      int slot_index = slot.GetSlotIndex();
      slot.SetPlant(this); // hack
 
      ctx.Write(slot_index);
 
      OnStoreSaveCustom(ctx);
    }
    else
    {
      GetGame().ObjectDelete(this); // Plants that exist without a garden must be deleted. Otherwise they might cause problems.
      Print("Warning! A plant existed without a garden. Therefore it was deleted from the world to prevent issues!");
    }
  }
 
  string GetCropsType()
  {
    return m_CropsType;
  }
 
 
  bool OnStoreLoadCustom(ParamsReadContext ctx, int version)
  {
    int loadInt;
    if (!ctx.Read(loadInt))
      loadInt = 0;
 
    m_SprayUsage = loadInt;
 
    loadInt = 0;
    if (!ctx.Read(loadInt))
      loadInt = 5;
 
    m_DeleteDryPlantTime = loadInt;
 
    loadInt = 0;
    if (!ctx.Read(loadInt))
      loadInt = 5;
    m_SpoiledRemoveTime = loadInt;
 
    loadInt = 0;
    if (!ctx.Read(loadInt))
      loadInt = 300;
    m_FullMaturityTime = loadInt;
 
    loadInt = 0;
    if (!ctx.Read(loadInt))
      loadInt = 300;
    m_SpoilAfterFullMaturityTime = loadInt;
 
    loadInt = 0;
    if (!ctx.Read(loadInt))
      return false;
    m_StateChangeTime = loadInt;
 
    float loadFloat = 0.0;
    if (!ctx.Read(loadFloat))
      loadFloat = 0;
    m_InfestationChance = loadFloat;
 
    loadInt = 0;
    if (!ctx.Read(loadInt))
      return false;
    m_GrowthStagesCount = loadInt;
 
    loadInt = 0;
    if (!ctx.Read(loadInt))
      loadInt = 1;
    m_CropsCount = loadInt;
 
    string loadString = "";
    if (!ctx.Read(loadString))
      return false;
    m_CropsType = loadString;
 
    loadFloat = 0.0;
    if (!ctx.Read(loadFloat))
      loadFloat = 1;
    m_PlantMaterialMultiplier = loadFloat;
 
    loadInt = 0;
    if (!ctx.Read(loadInt))
      loadInt = 1;
    m_PlantState = loadInt;
 
    loadInt = 0;
    if (!ctx.Read(loadInt))
      loadInt = 0;
    m_PlantStateIndex = loadInt;
 
    loadFloat = 0.0;
    if (!ctx.Read(loadFloat))
      loadFloat = 1;
    m_CurrentPlantMaterialQuantity = loadFloat;
 
    bool loadBool = false;
    if (!ctx.Read(loadBool))
      loadBool = false;
    m_IsInfested = loadBool;
 
    loadFloat = 0.0;
    if (!ctx.Read(loadFloat))
      loadFloat = 0;
    m_SprayQuantity = loadFloat;
 
 
    loadBool = false;
    if (ctx.Read(loadBool))
    {
      if (loadBool)
      {
        if (GetGame().IsServer())
        {
          m_GrowthTimer = new Timer(CALL_CATEGORY_SYSTEM);
          m_GrowthTimer.Run(m_StateChangeTime, this, "GrowthTimerTick", NULL, true);
        }
      }
    }
    else
      return false;
 
    loadFloat = 0.0;
    if (ctx.Read(loadFloat))
    {
      if (loadFloat > 0.0)
      {
        if (GetGame().IsServer())
        {
          m_InfestationTimer = new Timer(CALL_CATEGORY_SYSTEM);
          m_InfestationTimer.Run(loadFloat, this, "InfestationTimerTick", NULL, false);
        }
      }
    }
    else
      return false;
 
    loadFloat = 0.0;
    if (ctx.Read(loadFloat))
    {
      if (loadFloat > 0.0)
      {
        if (GetGame().IsServer())
        {
          m_SpoilAfterFullMaturityTimer = new Timer(CALL_CATEGORY_SYSTEM);
          m_SpoilAfterFullMaturityTimer.Run(loadFloat, this, "SetSpoiled", NULL, false);
        }
      }
    }
    else
      return false;
 
    loadFloat = 0.0;
    if (ctx.Read(loadFloat))
    {
      if (loadFloat > 0.0)
      {
        if (GetGame().IsServer())
        {
          if (!m_SpoiledRemoveTimer)
            m_SpoiledRemoveTimer = new Timer(CALL_CATEGORY_SYSTEM);
 
          m_SpoiledRemoveTimer.Run(loadFloat, this, "SpoiledRemoveTimerTick", NULL, false);
        }
      }
    }
    else
      return false;
 
    loadFloat = 0.0;
    if (ctx.Read(loadFloat))
    {
      if (loadFloat > 0.0)
      {
        if (GetGame().IsServer())
        {
          m_DeleteDryPlantTimer = new Timer(CALL_CATEGORY_SYSTEM);
          m_DeleteDryPlantTimer.Run(loadFloat, this, "DeleteDryPlantTick", NULL, false);
        }
      }
    }
    else
      return false;
 
 
    UpdatePlant();
    return true;
  }
 
  void OnStoreSaveCustom(ParamsWriteContext ctx)
  {
    ctx.Write(m_SprayUsage);
 
    ctx.Write(m_DeleteDryPlantTime);
 
    ctx.Write(m_SpoiledRemoveTime);
 
    ctx.Write(m_FullMaturityTime);
 
    ctx.Write(m_SpoilAfterFullMaturityTime);
 
    ctx.Write(m_StateChangeTime);
 
    ctx.Write(m_InfestationChance);
 
    ctx.Write(m_GrowthStagesCount);
 
    ctx.Write(m_CropsCount);
 
    ctx.Write(m_CropsType);
 
    ctx.Write(m_PlantMaterialMultiplier);
 
    ctx.Write(m_PlantState);
 
    ctx.Write(m_PlantStateIndex);
 
    ctx.Write(m_CurrentPlantMaterialQuantity);
 
    ctx.Write(m_IsInfested);
 
    ctx.Write(m_SprayQuantity);
 
    bool saveBool = false;
    if (m_GrowthTimer != NULL)
      saveBool = true;
    ctx.Write(saveBool);
 
    float saveFloat = 0.0;
    if (m_InfestationTimer != NULL)
      saveFloat = m_InfestationTimer.GetRemaining();
    ctx.Write(saveFloat);
 
    saveFloat = 0.0;
    if (m_SpoilAfterFullMaturityTimer != NULL)
      saveFloat = m_SpoilAfterFullMaturityTimer.GetRemaining();
    ctx.Write(saveFloat);
 
    saveFloat = 0.0;
    if (m_SpoiledRemoveTimer != NULL)
      saveFloat = m_SpoiledRemoveTimer.GetRemaining();
    ctx.Write(saveFloat);
 
    saveFloat = 0.0;
    if (m_DeleteDryPlantTimer != NULL)
      saveFloat = m_DeleteDryPlantTimer.GetRemaining();
    ctx.Write(saveFloat);
  }
 
  void PrintValues()
  {
    Print("PRINT ALL VALUES OF PLANT...");
    Print(this);
 
    Print(m_HasCrops);
    Print(m_PlantState);
    Print(m_PlantStateIndex);
    Print(m_CurrentPlantMaterialQuantity);
    Print(m_IsInfested);
    Print(m_SprayQuantity);
    Print(m_Slot);
    Print(m_GardenBase);
    Print("----------------------------------------------------------");
  }
 
  override bool CanPutInCargo(EntityAI parent)
  {
    return super.CanPutInCargo(parent);
  }
 
  override bool CanPutIntoHands(EntityAI player)
  {
    return super.CanPutIntoHands(parent);
  }
 
  override bool CanRemoveFromHands(EntityAI player)
  {
    return false;
  }
 
  void ChangeInfestation(bool is_infested)
  {
    m_IsInfested = is_infested;
 
    string plant_type = GetType();
    PlantMaterialHealth material = m_ModuleHorticulture.GetPlantMaterial(plant_type);
 
    if (m_IsInfested)
    {
      if (material.m_InfestedTex != "")
        SetObjectTexture(0, material.m_InfestedTex);
      if (material.m_InfestedMat != "")
        SetObjectMaterial(0, material.m_InfestedMat);
    }
    else
    {
      if (material.m_HealthyTex != "")
        SetObjectTexture(0, material.m_HealthyTex);
      if (material.m_HealthyMat != "")
        SetObjectMaterial(0, material.m_HealthyMat);
    }
  }
 
  void UpdatePlant()
  {
    if (m_PlantStateIndex > 0)
    {
      string plant_state_index = m_PlantStateIndex.ToStringLen(2);
      string prev_plant_state_index = (m_PlantStateIndex - 1).ToStringLen(2);
 
      // HIDING PREVIOUS PLANT STATE AND SHOWING THE CURRENT ONE
      ShowSelection("plantStage_" + plant_state_index); // SHOW!
      HideSelection("plantStage_" + prev_plant_state_index); // HIDE!
 
      // HIDING PREVIOUS CROPS STATE AND SHOWING THE CURRENT ONE
 
      if (HasCrops())
      {
        ShowSelection("plantStage_" + plant_state_index + "_crops"); // SHOW!
        HideSelection("plantStage_" + prev_plant_state_index + "_crops"); // HIDE!
      }
      else
      {
        HideSelection("plantStage_" + plant_state_index + "_crops"); // HIDE!
        HideSelection("plantStage_" + prev_plant_state_index + "_crops"); // HIDE!
      }
 
      // HIDING PREVIOUS SHADOW STATE AND SHOWING THE CURRENT ONE
      ShowSelection("plantStage_" + plant_state_index + "_shadow"); // SHOW!
      HideSelection("plantStage_" + prev_plant_state_index + "_shadow"); // HIDE!
    }
 
    float float_plant_state_index = (float)m_PlantStateIndex;
    m_CurrentPlantMaterialQuantity = m_PlantMaterialMultiplier * float_plant_state_index;
  }
 
  void GrowthTimerTick()
  {
    if (IsGrowing())
    {
      if (m_PlantStateIndex < m_GrowthStagesCount - 2)
      {
        m_PlantStateIndex++;
        UpdatePlant();
        SetSynchDirty();
 
        if (m_PlantStateIndex == 0)
        {
          float infestation_time_min = (float)m_FullMaturityTime * 0.2;
          int int_infestation_time_min = (int)infestation_time_min;
 
          float infestation_time_max = (float)m_FullMaturityTime * 0.6;
          int int_infestation_time_max = (int)infestation_time_max;
 
          if (GetGame().IsServer())
          {
            if (!m_InfestationTimer)
              m_InfestationTimer = new Timer(CALL_CATEGORY_SYSTEM);
 
            m_InfestationTimer.Run(Math.RandomInt(int_infestation_time_min, int_infestation_time_max), this, "InfestationTimerTick", NULL, false);
          }
        }
 
        if (m_PlantStateIndex == m_GrowthStagesCount - 2)
        {
          if (m_IsInfested)
            SetSpoiled();
          else
            SetPlantState(STATE_MATURE);
        }
      }
    }
    else if (IsMature())
    {
      if (GetGame().IsServer())
      {
        if (!m_SpoilAfterFullMaturityTimer)
          m_SpoilAfterFullMaturityTimer = new Timer(CALL_CATEGORY_SYSTEM);
 
        if (!m_SpoilAfterFullMaturityTimer.IsRunning())
          m_SpoilAfterFullMaturityTimer.Run(m_SpoilAfterFullMaturityTime, this, "SetSpoiled", NULL, false);
      }
    }
  }
 
  void InfestationTimerTick()
  {
    float infestation_rnd = Math.RandomFloat01();
 
    if (m_InfestationChance > infestation_rnd)
      ChangeInfestation(true);
  }
 
  void SpoiledRemoveTimerTick()
  {
    if (m_GrowthTimer != NULL)
      m_GrowthTimer.Stop();
 
    RemoveSlot();
  }
 
  void DeleteDryPlantTick()
  {
    /*if ( IsDry() )
      {
      RemoveSlot();
      }*/
  }
 
  void SetSpoiled()
  {
    if (IsSpoiled() == false)
    {
      m_PlantStateIndex++;
      SetPlantState(STATE_SPOILED);
      UpdatePlant();
      SetSynchDirty();
 
      if (GetGame().IsServer())
      {
        if (!m_SpoiledRemoveTimer)
          m_SpoiledRemoveTimer = new Timer(CALL_CATEGORY_SYSTEM);
 
        if (!m_SpoiledRemoveTimer.IsRunning())
          m_SpoiledRemoveTimer.Run(m_SpoiledRemoveTime, this, "SpoiledRemoveTimerTick", NULL, false);
      }
    }
  }
 
  void CheckWater()
  {
    if (!IsMature() && !NeedsWater())
    {
      if (m_DeleteDryPlantTimer)
        m_DeleteDryPlantTimer.Stop();
 
      SetPlantState(STATE_GROWING);
 
      if (GetGame().IsServer())
      {
        m_GrowthTimer = new Timer(CALL_CATEGORY_SYSTEM);
        m_GrowthTimer.Run(m_StateChangeTime, this, "GrowthTimerTick", NULL, true);
      }
    }
  }
 
  //NEW METHOD FOR PLANT SPRAYING
  void SprayPlant(float consumed_quantity)
  {
    //Rework this to have something smooth
    m_SprayQuantity += consumed_quantity;
 
    if (!NeedsSpraying())
    {
      if (m_InfestationTimer != NULL)
        m_InfestationTimer.Stop();
 
      m_IsInfested = false;
      m_InfestationChance = 0;
 
      ChangeInfestation(false);
      UpdatePlant();
    }
  }
 
  //DEPRECATED
  string StopInfestation(float consumed_quantity)
  {
    m_SprayQuantity += consumed_quantity;
 
    if (!NeedsSpraying())
    {
      if (m_InfestationTimer != NULL)
        m_InfestationTimer.Stop();
 
      m_IsInfested = false;
      m_InfestationChance = 0;
 
      ChangeInfestation(false);
      UpdatePlant();
 
      return "I've sprayed the plant a bit. Now it is enough spayed.";
    }
    else
      return "I've sprayed the plant a bit.";
  }
 
  //DEPRECATED
  void RemovePlant()
  {
    if (GetGame() && GetGame().IsServer())
    {
      UnlockFromParent();
 
      if (m_CurrentPlantMaterialQuantity > 0.0)
      {
        vector pos = GetPosition();
        ItemBase item = ItemBase.Cast(GetGame().CreateObjectEx("PlantMaterial", pos, ECE_PLACE_ON_SURFACE));
        item.SetQuantity(m_CurrentPlantMaterialQuantity * 1000.0);
      }
 
      RemoveSlot();
    }
  }
 
  void RemovePlantEx(vector pos)
  {
    if (GetGame() && GetGame().IsServer())
    {
      UnlockFromParent();
 
      if (m_CurrentPlantMaterialQuantity > 0.0)
      {
        ItemBase item = ItemBase.Cast(GetGame().CreateObjectEx("PlantMaterial", pos, ECE_PLACE_ON_SURFACE));
        item.SetQuantity(m_CurrentPlantMaterialQuantity * 1000.0);
      }
 
      RemoveSlot();
    }
  }
 
  void DestroyPlant()
  {
    if (GetGame() && GetGame().IsServer())
    {
      UnlockFromParent();
 
      RemoveSlot();
    }
  }
 
  void Harvest(PlayerBase player)
  {
    //TODO Boris: Add soft skill 2.0
    //PluginExperience module_exp = GetPlugin(PluginExperience);
    //float harvesting_efficiency = module_exp.GetExpParamNumber(player, PluginExperience.EXP_FARMER_HARVESTING, "efficiency");
 
    //m_CropsCount = m_CropsCount * harvesting_efficiency;
 
    if (!IsSpoiled())
    {
      for (int i = 0; i < m_CropsCount; i++)
      {
        vector pos = player.GetPosition();
        ItemBase item = ItemBase.Cast(GetGame().CreateObjectEx(m_CropsType, pos, ECE_PLACE_ON_SURFACE));
        item.SetQuantity(item.GetQuantityMax());
      }
    }
 
    m_HasCrops = false;
    SetSynchDirty();
    UpdatePlant();
  }
 
  void SetPlantState(int state)
  {
    m_PlantState = state;
    SetSynchDirty();
  }
 
  int GetPlantState()
  {
    return m_PlantState;
  }
 
  int GetPlantStateIndex()
  {
    return m_PlantStateIndex;
  }
 
  float GetWater()
  {
    if (GetSlot())
      return GetSlot().GetWater();
 
    return 0;
  }
 
  float GetWaterMax()
  {
    if (GetSlot())
      return GetSlot().GetWaterUsage();
 
    return 0;
  }
 
  bool NeedsWater()
  {
    Slot slotPlant = m_Slot;
 
    if (IsDry() && slotPlant && slotPlant.GetWater() < slotPlant.GetWaterUsage())
      return true;
    else
      return false;
  }
 
  bool NeedsSpraying()
  {
    if (m_SprayQuantity < m_SprayUsage)
      return true;
    else
      return false;
  }
 
  float GetSprayQuantity()
  {
    return m_SprayQuantity;
  }
 
  float GetSprayUsage()
  {
    return m_SprayUsage;
  }
 
  void RemoveSlot()
  {
    GardenBase garden = GardenBase.Cast(GetHierarchyParent());
 
    if (garden)
    {
      if (m_SpoiledRemoveTimer)
      {
        m_SpoiledRemoveTimer.Stop();
        m_SpoiledRemoveTimer = NULL;
      }
 
      garden.RemoveSlotPlant(this);
    }
  }
 
  void SetSlot(Slot slot)
  {
    if (slot)
      m_Slot = slot;
  }
 
  Slot GetSlot()
  {
    return m_Slot;
  }
 
  GardenBase GetGarden()
  {
    return m_GardenBase;
  }
 
  bool IsDry()
  {
    if (GetPlantState() == STATE_DRY)
      return true;
    else
      return false;
  }
 
  bool IsGrowing()
  {
    if (GetPlantState() == STATE_GROWING)
      return true;
    else
      return false;
  }
 
 
  bool IsMature()
  {
    if (GetPlantState() == STATE_MATURE)
      return true;
    else
      return false;
  }
 
  bool IsSpoiled()
  {
    if (GetPlantState() == STATE_SPOILED)
      return true;
    else
      return false;
  }
 
  bool HasCrops()
  {
    return m_HasCrops;
  }
 
  override void SetActions()
  {
    super.SetActions();
 
    AddAction(ActionHarvestCrops);
    AddAction(ActionRemovePlant);
  }
}