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