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