Slot.c

См. документацию.

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;
    float m_FertilizerQuantityMax;  // how much of a fertilizer can the slot contain
    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 (!g_Game.IsServer())
            return;
        
        if (!GetPlant() && GetSeed() && !NeedsWater()) // if there is no seed then do not create plant. Plant will be created when the seed is inserted into watered slot.
            GetGarden().CreatePlant(this);
        
        if ( needed_water != NeedsWater() )
        {
            SetWateredState( eWateredState.WET );
            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;
    }
 
    void SetFertilizerQuantity(float fertility)
    {
        m_FertilizerQuantity = fertility;
    }
    
    float GetFertilizerQuantityMax()
    {
        return m_FertilizerQuantityMax;
    }
    
    void SetFertilizerQuantityMax(float quantMax)
    {
        m_FertilizerQuantityMax = quantMax;
    }
    
    
    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 );
    }
}