fryingpan.c

Go to the documentation of this file.

class FryingPan extends Inventory_Base
{
 // Cooking data
 protected CookingMethodType m_CookingMethod;
 protected bool m_CookingIsDone;
 protected bool m_CookingIsEmpty;
 protected bool m_CookingIsBurned;
 
 // Particles
 protected Particle m_ParticleCooking;
 protected int m_ParticlePlaying = ParticleList.INVALID;
 
 protected int PARTICLE_BAKING_START = ParticleList.COOKING_BAKING_START;
 protected int PARTICLE_BAKING_DONE = ParticleList.COOKING_BAKING_DONE;
 protected int PARTICLE_DRYING_START = ParticleList.COOKING_DRYING_START;
 protected int PARTICLE_DRYING_DONE = ParticleList.COOKING_DRYING_DONE;
 protected int PARTICLE_BURNING_DONE = ParticleList.COOKING_BURNING_DONE;
 
 // Sounds
 protected SoundOnVehicle m_SoundCooking; 
 protected EffectSound m_SoundEffectCooking;
 protected string m_SoundPlaying = "";
 
 const string SOUND_BAKING_START = "Baking_SoundSet"; 
 const string SOUND_BAKING_DONE = "Baking_Done_SoundSet"; 
 const string SOUND_DRYING_START = "Drying_SoundSet"; 
 const string SOUND_DRYING_DONE = "Drying_Done_SoundSet"; 
 const string SOUND_BURNING_DONE = "Food_Burning_SoundSet"; 
 
 void FryingPan()
 {
 RegisterNetSyncVariableInt( "m_CookingMethod", CookingMethodType.NONE, CookingMethodType.COUNT );
 RegisterNetSyncVariableBool( "m_CookingIsDone" );
 RegisterNetSyncVariableBool( "m_CookingIsEmpty" );
 RegisterNetSyncVariableBool( "m_CookingIsBurned" );
 }
 void ~FryingPan() {}
 
 override bool IsContainer()
 {
 return true; 
 }
 
 override bool CanHaveTemperature()
 {
 return true;
 }
 
 override bool CanPutInCargo( EntityAI parent )
 {
 if ( !super.CanPutInCargo( parent ) )
 return false;
 
 if ( parent && IsCargoException4x3( parent ) )
 return false;
 
 //is 'parent' somewhere in cargo?
 if (parent && parent.GetInventory().IsCargoInHiearchy())
 return false;
 
 return true;
 }
 
 override bool CanReceiveItemIntoCargo( EntityAI item )
 {
 if ( !super.CanReceiveItemIntoCargo( item ) )
 return false;
 
 if ( IsCargoException4x3( item ) )
 return false;
 
 //is 'this' somewhere in cargo?
 if (GetInventory().IsCargoInHiearchy())
 return false;
 
 //can 'this' be attached to the item (->assumed smaller size than item)?
 int slotId;
 for (int i = 0; i < GetInventory().GetSlotIdCount(); i++)
 {
 slotId = GetInventory().GetSlotId(i);
 if (item.GetInventory().HasAttachmentSlot(slotId))
 {
 //Print("CanReceiveItemIntoCargo | item " + item + " matches in slot name: " + InventorySlots.GetSlotName(slotId) + " of " + this);
 return false;
 }
 }
 
 return true;
 }
 
 override bool CanLoadItemIntoCargo( EntityAI item )
 {
 if ( !super.CanLoadItemIntoCargo( item ) )
 return false;
 
 if ( IsCargoException4x3( item ) )
 return false;
 
 //can 'this' be attached to the item (->assumed smaller size than item)?
 int slotId;
 for (int i = 0; i < GetInventory().GetSlotIdCount(); i++)
 {
 slotId = GetInventory().GetSlotId(i);
 if (item.GetInventory().HasAttachmentSlot(slotId))
 {
 //Print("CanLoadItemIntoCargo | item " + item + " matches in slot name: " + InventorySlots.GetSlotName(slotId) + " of " + this);
 return false;
 }
 }
 
 return true;
 }
 
 override void SetActions()
 {
 super.SetActions();
 
 AddAction(ActionCreateIndoorFireplace);
 AddAction(ActionCreateIndoorOven);
 AddAction(ActionAttach);
 AddAction(ActionDetach);
 }
 
 override void EEDelete( EntityAI parent )
 {
 super.EEDelete( parent );
 
 //remove audio visuals
 RemoveAudioVisuals();
 }
 
 void Synchronize()
 {
 if ( GetGame() && GetGame().IsServer() )
 {
 SetSynchDirty();
 }
 }
 
 override void OnVariablesSynchronized()
 {
 super.OnVariablesSynchronized();
 
 //refresh audio visuals
 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 )
 {
 int particleId;
 
 //if at least one of the food items is burned
 if (is_burned)
 {
 particleId = PARTICLE_BURNING_DONE;
 }
 //proper cooking methods
 else
 {
 if (cooking_method == CookingMethodType.BAKING)
 {
 if (is_done)
 particleId = PARTICLE_BAKING_DONE;
 else
 particleId = PARTICLE_BAKING_START;
 }
 else if (cooking_method == CookingMethodType.DRYING)
 {
 if (is_done)
 particleId = PARTICLE_DRYING_DONE;
 else
 particleId = PARTICLE_DRYING_START;
 } 
 }
 
 ParticleCookingStart(particleId);
 }
 
 void RemoveAudioVisuals()
 {
 ParticleCookingStop();
 }
 
 void ParticleCookingStart( int particle_id )
 {
 if ( m_ParticlePlaying != particle_id )
 {
 //stop previous particles
 ParticleCookingStop();
 
 //create new
 if ( GetGame() && ( !GetGame().IsDedicatedServer() ) )
 {
 vector local_pos = MiscGameplayFunctions.GetSteamPosition( GetHierarchyParent() );
 //TODO set steam position to pot (proxy) memory point (new hierarchy needed)
 //m_ParticleCooking = Particle.Create( particle_id, this, local_pos );
 m_ParticleCooking = ParticleManager.GetInstance().PlayInWorld( particle_id, local_pos );
 m_ParticlePlaying = particle_id;
 }
 }
 }
 void ParticleCookingStop()
 {
 if ( m_ParticleCooking && GetGame() && ( !GetGame().IsDedicatedServer() ) )
 {
 m_ParticleCooking.Stop();
 m_ParticleCooking = NULL;
 m_ParticlePlaying = ParticleList.INVALID;
 }
 }
 
 protected void SoundCookingStart(string sound_name);
 protected void SoundCookingStop();
}