bottle_base.c

Go to the documentation of this file.

enum SoundTypeBottle
{
    POURING         = 1,
    EMPTYING        = 0,    
}
 
class Bottle_Base extends Edible_Base
{
    //Particles
    protected Particle  m_ParticleCooking;
    protected int       m_ParticlePlaying   = ParticleList.INVALID;
    //Boiling
    //waiting for proper particle effects
    protected int PARTICLE_BOILING_EMPTY    = ParticleList.COOKING_BOILING_EMPTY;
    protected int PARTICLE_BOILING_START    = ParticleList.COOKING_BOILING_START;
    protected int PARTICLE_BOILING_DONE     = ParticleList.COOKING_BOILING_DONE;
    //Baking
    protected int PARTICLE_BAKING_START     = ParticleList.COOKING_BAKING_START;
    protected int PARTICLE_BAKING_DONE      = ParticleList.COOKING_BAKING_DONE;
    //Drying
    protected int PARTICLE_DRYING_START     = ParticleList.COOKING_DRYING_START;
    protected int PARTICLE_DRYING_DONE      = ParticleList.COOKING_DRYING_DONE;
    //Burning
    protected int PARTICLE_BURNING_DONE     = ParticleList.COOKING_BURNING_DONE;
    
    //Sounds
    protected EffectSound   m_PouringLoopSound;
    protected EffectSound   m_EmptyingLoopSound;
    
    //cooking data
    protected CookingMethodType     m_CookingMethod;
    protected bool                  m_CookingIsDone;
    protected bool                  m_CookingIsEmpty;
    protected bool                  m_CookingIsBurned;  
    
    //Boiling
    const string SOUND_BOILING_EMPTY        = "Boiling_SoundSet";
    const string SOUND_BOILING_START        = "Boiling_SoundSet";
    const string SOUND_BOILING_DONE         = "Boiling_Done_SoundSet";
    const string SOUND_DRYING_START         = "Drying_SoundSet";
    const string SOUND_DRYING_DONE          = "Drying_Done_SoundSet";
    
    float m_LiquidEmptyRate;
    private const float QUANTITY_EMPTIED_PER_SEC_DEFAULT = 200; //default
        
    void Bottle_Base()
    {
        RegisterNetSyncVariableInt("m_CookingMethod", CookingMethodType.NONE, CookingMethodType.COUNT);
        RegisterNetSyncVariableBool("m_CookingIsDone");
        RegisterNetSyncVariableBool("m_CookingIsEmpty");
        RegisterNetSyncVariableBool("m_CookingIsBurned");
        
        m_LiquidEmptyRate = QUANTITY_EMPTIED_PER_SEC_DEFAULT;
    }
    
    void ~Bottle_Base()
    {
        SEffectManager.DestroyEffect(m_PouringLoopSound);
        SEffectManager.DestroyEffect(m_EmptyingLoopSound);
    }
    
    override void EEDelete( EntityAI parent )
    {
        super.EEDelete( parent );
        
        //remove audio visuals
        RemoveAudioVisuals();
    }   
    
    override void EECargoIn(EntityAI item)
    {
        super.EECargoIn(item);
        
        MiscGameplayFunctions.SoakItemInsideParentContainingLiquidAboveThreshold(ItemBase.Cast(item), this);
    }
    
    //================================================================
    // PARTICLES & SOUNDS
    //================================================================
    //Refreshes the audio and partcile effects on cooking pot
    //is_done - is the food baked, boiled, dried?
    //is_empty - is cooking quipment (cargo) empty?
    //is_burned - is any of the food items in the cargo in burned food stage?
    override void Synchronize()
    {
        SetSynchDirty();
    }
    
    override void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx) 
    {
        super.OnRPC(sender, rpc_type, ctx);
        
        Param1<bool> p = new Param1<bool>(false);
                
        if (!ctx.Read(p))
            return;
        
        bool play = p.param1;
        switch (rpc_type)
        {
            case SoundTypeBottle.POURING:
                if (play)
                    PlayPouringLoopSound();
                else
                    StopPouringLoopSound();         
 
                break;
            
            case SoundTypeBottle.EMPTYING:
                if (play)
                    PlayEmptyingLoopSound();
                else
                    StopEmptyingLoopSound();
            
                break;
        }
    }
    
    override void OnVariablesSynchronized()
    {
        super.OnVariablesSynchronized();
 
        if (m_CookingMethod != CookingMethodType.NONE)
        {
            RefreshAudioVisuals(m_CookingMethod, m_CookingIsDone, m_CookingIsEmpty, m_CookingIsBurned);
        }
        else
        {
            RemoveAudioVisuals();
        }
    }
    
    void RemoveAudioVisualsOnClient()
    {
        m_CookingMethod = CookingMethodType.NONE;
        
        Synchronize();
    }
    
    void RefreshAudioVisualsOnClient( CookingMethodType cooking_method, bool is_done, bool is_empty, bool is_burned )
    {
        m_CookingMethod     = cooking_method;
        m_CookingIsDone     = is_done;
        m_CookingIsEmpty    = is_empty;
        m_CookingIsBurned   = is_burned;
 
        Synchronize();
    }
    
    void RefreshAudioVisuals(CookingMethodType cooking_method, bool is_done, bool is_empty, bool is_burned)
    {
        string soundName;
        int particleId;
        
        //if at least one of the food items is burned
        if (is_burned)
        {
            soundName   = SOUND_BURNING_DONE;
            particleId  = PARTICLE_BURNING_DONE;
        }
        //proper cooking methods
        else
        {
            switch (cooking_method)
            {
                case CookingMethodType.BOILING:
                    if (is_empty)
                    {
                        soundName   = SOUND_BOILING_EMPTY;
                        particleId  = PARTICLE_BOILING_EMPTY;
                    }
                    else
                    {
                        if (is_done)
                        {
                            soundName   = SOUND_BOILING_DONE;
                            particleId  = PARTICLE_BOILING_DONE;
                        }
                        else
                        {
                            soundName   = SOUND_BOILING_START;
                            particleId  = PARTICLE_BOILING_START;
                        }
                    }
 
                    break;
 
                case CookingMethodType.BAKING:
                    if (is_done)
                    {
                        soundName   = SOUND_BAKING_DONE;
                        particleId  = PARTICLE_BAKING_DONE;
                    }
                    else
                    {
                        soundName   = SOUND_BAKING_START;
                        particleId  = PARTICLE_BAKING_START ;
                    }
 
                    break;
 
                case CookingMethodType.DRYING:
                    if (is_done)
                    {
                        soundName   = SOUND_DRYING_DONE;
                        particleId  = PARTICLE_DRYING_DONE;
                    }
                    else
                    {
                        soundName   = SOUND_DRYING_START;
                        particleId  = PARTICLE_DRYING_START;
                    }
                
                    break;
                
                default:
                    soundName = "";
                    particleId = ParticleList.NONE;
 
                    break;
            }
        }
        
        //play effects
        ParticleCookingStart(particleId);
        SoundCookingStart(soundName);
    }
    
    void RemoveAudioVisuals()
    {
        ParticleCookingStop();
        SoundCookingStop();
    }
    
    //particles
    void ParticleCookingStart(int particle_id)
    {
        #ifndef SERVER
        if (m_ParticlePlaying != particle_id)
        {
            //stop previous particles
            ParticleCookingStop();
            
            //create new
            vector localPos = MiscGameplayFunctions.GetSteamPosition(GetHierarchyParent());
            m_ParticleCooking = ParticleManager.GetInstance().PlayInWorld(particle_id, localPos);
            m_ParticlePlaying = particle_id;
        
        }
        #endif
    }
    
    void ParticleCookingStop()
    {
        if (m_ParticleCooking && GetGame() && !GetGame().IsDedicatedServer())
        {
            m_ParticleCooking.Stop();
            m_ParticleCooking = null;
            m_ParticlePlaying = ParticleList.INVALID;
        }
    }
        
    void PlayPouringLoopSound()
    {
        if (!m_PouringLoopSound || !m_PouringLoopSound.IsSoundPlaying())
        {
            m_PouringLoopSound = SEffectManager.PlaySoundOnObject(GetPouringSoundset(), this, 0, 0, true);
        }
    }
    
    void StopPouringLoopSound()
    {
        if (m_PouringLoopSound)
            m_PouringLoopSound.SoundStop();
    }
        
    void PlayEmptyingLoopSound()
    {
        if (!m_EmptyingLoopSound || !m_EmptyingLoopSound.IsSoundPlaying())
        {
            m_EmptyingLoopSound = SEffectManager.PlaySoundOnObject(GetEmptyingLoopSoundset(), this, 0, 0, true);
        }
    }
    
    void StopEmptyingLoopSound()
    {
        if (m_EmptyingLoopSound)
            m_EmptyingLoopSound.SoundStop();
                
        EffectSound sound = SEffectManager.PlaySoundOnObject(GetEmptyingEndSoundset(), this);
        sound.SetAutodestroy(true);
    }
        
    string GetEmptyingLoopSoundset()
    {       
        vector pos = GetPosition();
        string surfaceType = GetGame().GetPlayer().GetSurfaceType();
        string soundSet = "";
        
        bool diggable = GetGame().IsSurfaceDigable(surfaceType);
        
        if (!diggable)
        {
            soundSet = GetEmptyingLoopSoundsetHard();
        }
        else if (diggable)
        {
            soundSet = GetEmptyingLoopSoundsetSoft();
        }
        else if (GetGame().SurfaceIsPond(pos[0], pos[2]) || GetGame().SurfaceIsSea(pos[0], pos[2]))
        {
            soundSet = GetEmptyingLoopSoundsetWater();
        }
        
        return soundSet;
    }
    
    string GetEmptyingEndSoundset()
    {       
        vector pos = GetPosition();
        string surfaceType = GetGame().GetPlayer().GetSurfaceType();
        string soundSet = "";
        
        bool diggable = GetGame().IsSurfaceDigable(surfaceType);
        
        if (!diggable)
        {
            soundSet = GetEmptyingEndSoundsetHard();
        }
        else if (diggable)
        {
            soundSet = GetEmptyingEndSoundsetSoft();
        }
        else if (GetGame().SurfaceIsPond(pos[0], pos[2]) || GetGame().SurfaceIsSea(pos[0], pos[2]))
        {
            soundSet = GetEmptyingEndSoundsetWater();
        }
        
        return soundSet;
    }
 
    string GetPouringSoundset();
    string GetEmptyingLoopSoundsetHard();
    string GetEmptyingLoopSoundsetSoft();
    string GetEmptyingLoopSoundsetWater();
    string GetEmptyingEndSoundsetHard();
    string GetEmptyingEndSoundsetSoft();
    string GetEmptyingEndSoundsetWater();
    
    float GetLiquidEmptyRate()
    {
        return m_LiquidEmptyRate;
    }
        
    override void SetActions()
    {
        super.SetActions();
        
        AddAction(ActionFillFuel);
        AddAction(ActionFillCoolant);
        AddAction(ActionFillGeneratorTank);
        AddAction(ActionExtinguishFireplaceByLiquid);
        AddAction(ActionFillBottleBase);
        AddAction(ActionWaterGardenSlot);
        AddAction(ActionWaterPlant);
        AddAction(ActionForceDrink);
        AddAction(ActionDrainLiquid);
        AddAction(ActionPourLiquid);
        AddAction(ActionWashHandsItemContinuous);
        AddAction(ActionDrink);
        AddAction(ActionEmptyBottleBase);
    }
    
    override void OnDebugSpawn()
    {
        SetQuantityMax();
    }
}