slot.c

Go to the documentation of this file.

enum eFertlityState
{
 NONE = 0,
 FERTILIZED = 1
 //This will be used to set bit values (DO NOT ADD MORE VALUES)
}
 
enum eWateredState
{
 DRY = 0,
 WET = 1
 //Used to improve readability of watered state changes
}
 
class Slot
{
 static const int STATE_DIGGED = 1;
 static const int STATE_PLANTED = 2;
 
 private int m_WaterQuantity;
 static private int m_WaterNeeded = 190; // How much water is needed to water a plant from a bottle. Value is in mililitres
 static private int m_WaterMax = 200; 
 
 float m_Fertility;
 float m_FertilizerUsage;
 float m_FertilizerQuantity;
 int m_slotIndex;
 int m_slotId;
 
 string m_FertilizerType;
 int m_FertilityState = eFertlityState.NONE;
 int m_WateredState = eWateredState.DRY;
 string m_DiggedSlotComponent; // example: "Component02" for the 1st slot in GardenBase
 string m_PlantType;
 private ItemBase m_Seed;
 private GardenBase m_Garden;
 
 float m_HarvestingEfficiency;
 
 int m_State;
 
 private PlantBase m_Plant;
 
 void Slot( float base_fertility )
 {
 m_Seed = NULL;
 m_Plant = NULL;
 m_WaterQuantity = 0.0;
 Init( base_fertility );
 }
 
 void ~Slot()
 {
 if (m_Plant && GetGame()) // GetGame() returns NULL when the game is being quit!
 {
 GetGame().ObjectDelete( GetPlant() );
 }
 }
 
 int GetSlotIndex()
 {
 return m_slotIndex;
 }
 
 void SetSlotIndex(int index)
 {
 m_slotIndex = index;
 }
 
 int GetSlotId()
 {
 return m_slotId;
 }
 
 void SetSlotId(int id)
 {
 m_slotId = id;
 }
 
 void SetGarden(GardenBase garden)
 {
 m_Garden = garden;
 }
 
 GardenBase GetGarden()
 {
 return m_Garden;
 }
 
 void SetSeed(ItemBase seed)
 {
 m_Seed = seed;
 }
 
 PlantBase GetPlant()
 {
 return m_Plant;
 }
 
 void SetPlant(PlantBase plant)
 {
 m_Plant = plant;
 
 if (plant)
 {
 plant.SetSlot(this);
 }
 }
 
 //Used to force water level an go around sync issues
 void SetWater( int val )
 {
 val = Math.Clamp( val, 0, m_WaterMax );
 m_WaterQuantity = val;
 }
 
 ItemBase GetSeed()
 {
 return m_Seed;
 }
 
 bool HasSeed()
 {
 if (m_Seed)
 return true;
 
 return false;
 }
 
 void GiveWater( float consumed_quantity )
 {
 bool needed_water = NeedsWater();
 m_WaterQuantity += consumed_quantity;
 
 if (m_WaterQuantity >= GetWaterMax())
 m_WaterQuantity = GetWaterMax();
 
 if (m_WaterQuantity < 0)
 m_WaterQuantity = 0;
 
 if ( !NeedsWater() )
 {
 if ( !GetPlant() )
 {
 if ( GetSeed() )
 {
 GetGarden().CreatePlant(this);
 }
 
 // if there is no seed then do not create plant. Plant will be created when the seed is inserted into watered slot.
 }
 }
 
 if ( needed_water != NeedsWater() )
 {
 SetWateredState( eWateredState.WET );
 GetGarden().UpdateSlotTexture( GetSlotIndex() );
 if ( m_Garden.GetSlotWateredState() != m_Garden.GetMaxWaterStateVal() )
 m_Garden.SlotWaterStateUpdate( this );
 }
 }
 
 bool NeedsWater()
 {
 if ( m_WaterQuantity < GetWaterUsage() )
 {
 return true;
 }
 else
 {
 return false;
 }
 }
 
 bool CanBeWatered()
 {
 if ( m_WaterQuantity < GetWaterMax() )
 {
 return true;
 }
 else
 {
 return false;
 }
 }
 
 float GetWater()
 {
 return m_WaterQuantity;
 }
 
 float GetFertility()
 {
 return m_Fertility;
 }
 
 float GetFertilityMax()
 {
 return m_FertilizerUsage;
 }
 
 void SetFertility(float fertility)
 {
 m_Fertility = fertility;
 }
 
 float GetFertilizerQuantity()
 {
 return m_FertilizerQuantity;
 }
 
 float GetFertilizerQuantityMax()
 {
 return m_FertilizerUsage;
 }
 
 void SetFertilizerQuantity(float fertility)
 {
 m_FertilizerQuantity = fertility;
 }
 
 string GetFertilityType()
 {
 return m_FertilizerType;
 }
 
 void SetFertilityType(string type)
 {
 m_FertilizerType = type;
 }
 
 int GetFertilityState()
 {
 return m_FertilityState;
 }
 
 void SetFertilityState( int newState )
 {
 m_FertilityState = newState;
 }
 
 int GetWateredState()
 {
 return m_WateredState;
 }
 
 void SetWateredState( int newState )
 {
 m_WateredState = newState;
 if ( m_WateredState == eWateredState.WET )
 SetWater( GetWaterMax() );
 }
 
 float GetWaterUsage()
 {
 return m_WaterNeeded;
 }
 
 float GetWaterMax()
 {
 return m_WaterMax;
 }
 
 int GetState()
 {
 return m_State;
 }
 
 void SetState(int new_state)
 {
 m_State = new_state;
 }
 
 bool IsDigged()
 {
 if (m_State == STATE_DIGGED)
 {
 return true;
 }
 
 return false;
 }
 bool IsPlanted()
 {
 if (m_State == STATE_PLANTED)
 {
 return true;
 }
 
 return false;
 }
 
 void Init( float base_fertility )
 {
 m_Fertility = base_fertility;
 m_FertilizerUsage = 200;
 m_FertilizerQuantity = 0.0;
 m_FertilizerType = "";
 m_FertilityState = eFertlityState.NONE;
 
 m_WaterQuantity = 0;
 m_WateredState = eWateredState.DRY;
 
 m_HarvestingEfficiency = 1.0;
 //m_DiggedSlotComponent = "";
 m_State = STATE_DIGGED;
 m_Plant = NULL;
 }
 
 void SetSlotComponent(string component)
 {
 m_DiggedSlotComponent = component;
 }
 
 string GetSlotComponent()
 {
 return m_DiggedSlotComponent;
 }
 
 bool OnStoreLoadCustom( ParamsReadContext ctx, int version )
 {
 if ( version < 102 )
 {
 ctx.Read( m_Fertility );
 ctx.Read( m_FertilizerUsage );
 ctx.Read( m_FertilizerQuantity );
 
 if ( !ctx.Read( m_FertilizerType ) )
 m_FertilizerType = "";
 
 ctx.Read( m_HarvestingEfficiency );
 ctx.Read( m_State );
 }
 
 if ( version >= 102 )
 {
 ctx.Read( m_Fertility ); 
 ctx.Read( m_FertilizerUsage );
 ctx.Read( m_FertilizerQuantity ); 
 ctx.Read( m_HarvestingEfficiency );
 ctx.Read( m_State );
 
 if ( !ctx.Read( m_FertilizerType ) )
 {
 m_FertilizerType = "";
 }
 }
 
 return true;
 }
 
 void OnStoreSaveCustom( ParamsWriteContext ctx )
 {
 ctx.Write( m_Fertility );
 ctx.Write( m_FertilizerUsage );
 ctx.Write( m_FertilizerQuantity );
 ctx.Write( m_HarvestingEfficiency );
 ctx.Write( m_State );
 ctx.Write( m_FertilizerType );
 }
}