ovenindoor.c

Go to the documentation of this file.

class OvenIndoor extends FireplaceBase
{
 protected float m_SmokePosX;
 protected float m_SmokePosY;
 protected float m_SmokePosZ;
 protected int m_FirePointIndex = 1; //limited to 1 decimal place (1-9)
 
 static const string OVENPOINT_ACTION_SELECTION = "oven_action";
 static const string OVENPOINT_FIRE_POSITION = "oven_point";
 static const string OVENPOINT_PLACE_ROT = "oven_rot";
 static const string OVENPOINT_SMOKE_POSITION = "oven_smoke";
 
 void OvenIndoor()
 {
 //Particles - default for FireplaceBase
 PARTICLE_FIRE_START = ParticleList.OVEN_FIRE_START;
 PARTICLE_SMALL_FIRE = ParticleList.OVEN_SMALL_FIRE;
 PARTICLE_NORMAL_FIRE = ParticleList.OVEN_NORMAL_FIRE;
 PARTICLE_SMALL_SMOKE = ParticleList.HOUSE_SMALL_SMOKE;
 PARTICLE_NORMAL_SMOKE = ParticleList.HOUSE_NORMAL_SMOKE;
 PARTICLE_FIRE_END = ParticleList.OVEN_FIRE_END;
 PARTICLE_STEAM_END = ParticleList.BARREL_FIRE_STEAM_2END;
 
 //register sync variables
 RegisterNetSyncVariableFloat( "m_SmokePosX", 0, 0, 2 );
 RegisterNetSyncVariableFloat( "m_SmokePosY", 0, 0, 2 );
 RegisterNetSyncVariableFloat( "m_SmokePosZ", 0, 0, 2 );
 RegisterNetSyncVariableInt( "m_FirePointIndex", 0, 9 );
 
 m_LightDistance = 50;
 m_RoofAbove = true;
 }
 
 //================================================================
 // ONSTORESAVE/LOAD/AFTERLOAD
 //================================================================
 override void OnStoreSave( ParamsWriteContext ctx )
 { 
 super.OnStoreSave( ctx );
 
 //fire point name
 ctx.Write( m_FirePointIndex );
 
 //smoke position
 ctx.Write( m_SmokePosX );
 ctx.Write( m_SmokePosY );
 ctx.Write( m_SmokePosZ );
 }
 
 override bool OnStoreLoad( ParamsReadContext ctx, int version )
 {
 if ( !super.OnStoreLoad( ctx, version ) )
 return false;
 
 //--- Fireplace Indoor data ---
 //fire point name
 if ( !ctx.Read( m_FirePointIndex ) )
 {
 m_FirePointIndex = 1; //set default
 return false;
 }
 
 //smoke position
 if ( !ctx.Read( m_SmokePosX ) )
 {
 m_SmokePosX = 0; //set default
 return false;
 }
 if ( !ctx.Read( m_SmokePosY ) )
 {
 m_SmokePosY = 0; //set default
 return false;
 }
 if ( !ctx.Read( m_SmokePosZ ) )
 {
 m_SmokePosZ = 0; //set default
 return false;
 }
 //---
 
 return true;
 }
 
 //================================================================
 // FIRE POINT (HOUSE)
 // LIMITED TO 1 DECIMAL PLACE (0-9)
 //================================================================
 static int GetFirePointIndex( string action_selection )
 {
 int index_location = action_selection.Length() - 1;
 return action_selection.Substring( index_location, 1 ).ToInt();
 }
 
 void SetFirePointIndex( int fire_point_index )
 {
 m_FirePointIndex = fire_point_index;
 }
 
 static bool CanPlaceFireplaceInSelectedSpot( Object building, int fire_point_index, out vector fire_point_pos_world, out vector fire_point_rot_world )
 {
 //Get fire point index position
 vector fire_point_pos = building.GetSelectionPositionMS( OVENPOINT_FIRE_POSITION + fire_point_index.ToString() );
 vector fire_point_rot = building.GetSelectionPositionMS( OVENPOINT_PLACE_ROT + fire_point_index.ToString() );
 fire_point_pos_world = building.ModelToWorld( fire_point_pos );
 fire_point_rot_world = building.ModelToWorld( fire_point_rot );
 
 //check if there is any FireplaceIndoor objects near selected fire point
 ref array<Object> nearest_objects = new array<Object>;
 ref array<CargoBase> proxy_cargos = new array<CargoBase>;
 GetGame().GetObjectsAtPosition3D( fire_point_pos_world, 1, nearest_objects, proxy_cargos );
 
 for ( int i = 0; i < nearest_objects.Count(); ++i )
 {
 Object object = nearest_objects.Get( i );
 
 if ( object.IsInherited( OvenIndoor ) )
 {
 return false;
 }
 }
 
 return true;
 }
 
 void SetSmokePointPosition( vector smoke_point_pos )
 {
 m_SmokePosX = smoke_point_pos[0];
 m_SmokePosY = smoke_point_pos[1];
 m_SmokePosZ = smoke_point_pos[2];
 }
 
 //================================================================
 // PARTICLES
 //================================================================
 override protected vector GetSmokeEffectPosition()
 {
 return Vector( m_SmokePosX, m_SmokePosY, m_SmokePosZ );
 }
 
 //small smoke
 override void ParticleSmallSmokeStart()
 {
 PlayParticle( m_ParticleSmallSmoke, PARTICLE_SMALL_SMOKE, GetSmokeEffectPosition(), true );
 }
 
 //normal smoke
 override void ParticleNormalSmokeStart()
 {
 PlayParticle( m_ParticleNormalSmoke, PARTICLE_NORMAL_SMOKE, GetSmokeEffectPosition(), true );
 }
 
 //================================================================
 // STATE
 //================================================================
 override bool IsIndoorOven()
 {
 return true;
 }
 
 override bool CanReleaseAttachment(EntityAI attachment)
 {
 if (!super.CanReleaseAttachment(attachment))
 {
 return false;
 }
 
 ItemBase item = ItemBase.Cast(attachment);
 if (IsKindling(item) || IsFuel(item))
 {
 return !IsBurning();
 }
 
 return true;
 }
 
 override void EEItemAttached(EntityAI item, string slot_name)
 {
 super.EEItemAttached(item, slot_name);
 
 ItemBase item_base = ItemBase.Cast(item);
 
 if (IsKindling(item_base) || IsFuel(item_base))
 {
 AddToFireConsumables(item_base);
 }
 
 // direct cooking/smoking slots
 bool edible_base_attached = false;
 switch (slot_name)
 {
 case "DirectCookingA":
 m_DirectCookingSlots[0] = item_base;
 edible_base_attached = true;
 break;
 case "SmokingA":
 m_SmokingSlots[0] = item_base;
 edible_base_attached = true;
 break;
 case "SmokingB":
 m_SmokingSlots[1] = item_base;
 edible_base_attached = true;
 break;
 }
 
 // reset cooking time (to prevent the cooking exploit)
 if (GetGame().IsServer() && edible_base_attached)
 {
 Edible_Base edBase = Edible_Base.Cast(item_base);
 if (edBase)
 {
 if ( edBase.GetFoodStage())
 {
 edBase.SetCookingTime(0);
 }
 }
 }
 
 RefreshFireplaceVisuals();
 }
 
 override void EEItemDetached(EntityAI item, string slot_name) 
 {
 super.EEItemDetached(item, slot_name);
 
 ItemBase item_base = ItemBase.Cast(item);
 
 if (IsKindling(item_base) || IsFuel(item_base))
 {
 RemoveFromFireConsumables(GetFireConsumableByItem(item_base));
 }
 
 CheckForDestroy();
 
 // direct cooking/smoking slots
 switch (slot_name)
 {
 case "DirectCookingA":
 m_DirectCookingSlots[0] = null;
 break;
 case "SmokingA":
 m_SmokingSlots[0] = null;
 break;
 
 case "SmokingB":
 m_SmokingSlots[1] = null;
 break;
 }
 
 // cookware-specifics (remove audio visuals)
 if (item_base.Type() == ATTACHMENT_COOKING_POT)
 {
 ClearCookingEquipment(item_base);
 Bottle_Base cooking_pot = Bottle_Base.Cast(item);
 cooking_pot.RemoveAudioVisualsOnClient(); 
 }
 if (item_base.Type() == ATTACHMENT_CAULDRON)
 {
 ClearCookingEquipment(item_base);
 Bottle_Base cauldron = Bottle_Base.Cast(item);
 cauldron.RemoveAudioVisualsOnClient(); 
 }
 if (item_base.Type() == ATTACHMENT_FRYING_PAN)
 {
 ClearCookingEquipment(item_base);
 FryingPan frying_pan = FryingPan.Cast(item);
 frying_pan.RemoveAudioVisualsOnClient();
 }
 
 RefreshFireplaceVisuals();
 }
 
 //================================================================
 // CONDITIONS
 //================================================================
 //this into/outo parent.Cargo
 override bool CanPutInCargo( EntityAI parent )
 {
 return false;
 }
 
 override bool CanRemoveFromCargo( EntityAI parent )
 {
 return true;
 }
 
 //hands
 override bool CanPutIntoHands( EntityAI parent )
 {
 return false;
 }
 
 override bool CanRemoveFromHands( EntityAI player ) 
 {
 return false;
 }
 
 // Item-to-item fire distribution
 override bool HasFlammableMaterial()
 {
 return true;
 }
 
 override bool CanBeIgnitedBy( EntityAI igniter = NULL )
 {
 if ( HasAnyKindling() && !GetHierarchyParent() )
 {
 return true;
 }
 
 return false;
 }
 
 override bool CanIgniteItem( EntityAI ignite_target = NULL )
 {
 if ( IsBurning() )
 {
 return true;
 }
 
 return false;
 }
 
 override bool IsIgnited()
 {
 return IsBurning();
 }
 
 override void OnIgnitedTarget( EntityAI ignited_item )
 {
 }
 
 override void OnIgnitedThis( EntityAI fire_source )
 { 
 //start fire
 StartFire(); 
 }
 
 override bool IsThisIgnitionSuccessful( EntityAI item_source = NULL )
 {
 //check kindling
 if ( !HasAnyKindling() )
 {
 return false;
 }
 
 //check wetness
 if ( IsWet() )
 {
 return false;
 }
 
 return true; 
 }
}