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