fireplace.c

Go to the documentation of this file.

class Fireplace extends FireplaceBase
{
 bool m_ContactEventProcessing;
 
 void Fireplace()
 {
 //Particles - default for FireplaceBase
 PARTICLE_FIRE_START = ParticleList.CAMP_FIRE_START;
 PARTICLE_SMALL_FIRE = ParticleList.CAMP_SMALL_FIRE;
 PARTICLE_NORMAL_FIRE = ParticleList.CAMP_NORMAL_FIRE;
 PARTICLE_SMALL_SMOKE = ParticleList.CAMP_SMALL_SMOKE;
 PARTICLE_NORMAL_SMOKE = ParticleList.CAMP_NORMAL_SMOKE;
 PARTICLE_FIRE_END = ParticleList.CAMP_FIRE_END;
 PARTICLE_STEAM_END = ParticleList.CAMP_STEAM_2END;
 
 SetEventMask( EntityEvent.CONTACT | EntityEvent.TOUCH );
 }
 
 override bool IsBaseFireplace()
 {
 return true;
 }
 
 override void EOnTouch( IEntity other, int extra )
 {
 ContactEvent( other, GetPosition() );
 }
 
 override void EOnContact( IEntity other, Contact extra )
 {
 ContactEvent( other, extra.Position );
 }
 
 void ContactEvent( IEntity other, vector position )
 { 
 if ( GetGame().IsServer() && !m_ContactEventProcessing && dBodyIsActive(this) && !IsSetForDeletion() )
 {
 m_ContactEventProcessing = true;
 MiscGameplayFunctions.ThrowAllItemsInInventory(this, 0);
 CheckForDestroy();
 m_ContactEventProcessing = false;
 }
 }
 
 //attachments
 override bool CanReceiveAttachment( EntityAI attachment, int slotId )
 {
 if ( !super.CanReceiveAttachment(attachment, slotId) )
 return false;
 
 ItemBase item = ItemBase.Cast( attachment );
 
 //cookware
 if ( ( item.Type() == ATTACHMENT_CAULDRON ) || ( item.Type() == ATTACHMENT_COOKING_POT ) )
 {
 if ( FindAttachmentBySlotName( "CookingTripod" ) || IsOven() ) 
 return true;
 return false;
 }
 if ( item.Type() == ATTACHMENT_FRYING_PAN )
 {
 if ( IsOven() ) 
 return true;
 return false;
 }
 
 // food on direct cooking slots
 if ( item.IsKindOf( "Edible_Base" ) )
 {
 if ( IsOven() )
 return true;
 return false;
 }
 //tripod
 
 if ( item.IsInherited(TripodBase) )
 {
 if (!IsOven() && !GetHierarchyParent())
 return true;
 return false;
 }
 
 //stones
 if ( item.Type() == ATTACHMENT_STONES )
 {
 if ( !GetHierarchyParent() && !IsBurning() )
 return true;
 return false;
 }
 
 return true;
 }
 
 override bool CanDisplayAttachmentSlot( int slot_id )
 {
 string slot_name = InventorySlots.GetSlotName(slot_id);
 if ( super.CanDisplayAttachmentSlot(slot_id) )
 {
 if ( slot_name != "CookingEquipment" || FindAttachmentBySlotName( "CookingTripod" ) )
 return true;
 }
 
 return false;
 }
 
 override bool CanLoadAttachment( EntityAI attachment )
 {
 if ( !super.CanLoadAttachment(attachment) )
 return false;
 
 ItemBase item = ItemBase.Cast( attachment );
 
 //cookware
 if ( ( item.Type() == ATTACHMENT_CAULDRON ) || ( item.Type() == ATTACHMENT_COOKING_POT ) )
 {
 //if ( IsItemTypeAttached( ATTACHMENT_TRIPOD ) /*|| IsOven()*/ ) 
 return true;
 }
 if ( item.Type() == ATTACHMENT_FRYING_PAN )
 {
 //if ( IsOven() ) 
 return true;
 }
 
 // food on direct cooking slots
 //if ( IsOven() )
 //{
 if ( item.IsKindOf( "Edible_Base" ) )
 return true;
 //}
 //tripod
 if ( item.Type() == ATTACHMENT_TRIPOD )
 {
 if ( GetHierarchyParent() == NULL )
 return true;
 }
 
 //stones
 if ( item.Type() == ATTACHMENT_STONES )
 {
 if ( GetHierarchyParent() /*|| IsBurning()*/ )
 return false;
 
 return true;
 }
 
 return true;
 }
 
 override bool CanReleaseAttachment( EntityAI attachment )
 {
 if (!super.CanReleaseAttachment(attachment))
 {
 return false;
 }
 
 ItemBase item = ItemBase.Cast(attachment);
 //stones
 if (item.Type() == ATTACHMENT_STONES)
 {
 if (IsBurning())
 {
 return false;
 }
 
 int stone_quantity = item.GetQuantity();
 if (HasStoneCircle() && stone_quantity <= 8)
 {
 return false;
 }
 
 if (IsOven())
 {
 return false;
 }
 }
 
 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);
 }
 
 //cookware
 if (item_base.Type() == ATTACHMENT_COOKING_POT)
 {
 SetCookingEquipment(item_base);
 
 //rotate handle (if not in 'Oven' stage)
 if (GetGame().IsServer() && !IsOven())
 {
 item_base.SetAnimationPhase(ANIMATION_COOKWARE_HANDLE, 0);
 }
 }
 if (item.Type() == ATTACHMENT_CAULDRON)
 {
 SetCookingEquipment(item_base);
 
 //rotate handle (if not in 'Oven' stage)
 if (GetGame().IsServer() && !IsOven())
 {
 item_base.SetAnimationPhase(ANIMATION_CAULDRON_HANDLE, 0);
 }
 }
 
 // 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 "DirectCookingB":
 m_DirectCookingSlots[1] = item_base;
 edible_base_attached = true;
 break;
 case "DirectCookingC":
 m_DirectCookingSlots[2] = 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;
 case "SmokingC":
 m_SmokingSlots[2] = item_base;
 edible_base_attached = true;
 break;
 case "SmokingD":
 m_SmokingSlots[3] = 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);
 }
 }
 }
 
 //TODO
 //add SetViewIndex when attaching various attachments
 
 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));
 }
 
 //cookware
 if (item_base.Type() == ATTACHMENT_COOKING_POT)
 {
 ClearCookingEquipment(item_base);
 
 //rotate handle
 if (GetGame().IsServer())
 {
 item_base.SetAnimationPhase(ANIMATION_COOKWARE_HANDLE, 1);
 }
 
 //remove audio visuals
 Bottle_Base cooking_pot = Bottle_Base.Cast(item);
 cooking_pot.RemoveAudioVisualsOnClient();
 }
 if (item_base.Type() == ATTACHMENT_CAULDRON)
 {
 ClearCookingEquipment(item_base);
 
 //rotate handle
 if (GetGame().IsServer())
 {
 item_base.SetAnimationPhase(ANIMATION_CAULDRON_HANDLE, 1);
 }
 
 //remove audio visuals
 Bottle_Base cauldron = Bottle_Base.Cast( item );
 cauldron.RemoveAudioVisualsOnClient();
 }
 if (item_base.Type() == ATTACHMENT_FRYING_PAN)
 {
 ClearCookingEquipment(item_base);
 
 //remove audio visuals
 FryingPan frying_pan = FryingPan.Cast(item);
 frying_pan.RemoveAudioVisualsOnClient();
 }
 
 // direct cooking/smoking slots
 switch (slot_name)
 {
 case "DirectCookingA":
 m_DirectCookingSlots[0] = null;
 break;
 case "DirectCookingB":
 m_DirectCookingSlots[1] = null;
 break;
 case "DirectCookingC":
 m_DirectCookingSlots[2] = null;
 break;
 
 case "SmokingA":
 m_SmokingSlots[0] = null;
 break;
 case "SmokingB":
 m_SmokingSlots[1] = null;
 break;
 case "SmokingC":
 m_SmokingSlots[2] = null;
 break;
 case "SmokingD":
 m_SmokingSlots[3] = null;
 break;
 }
 
 //no attachments left, no cargo items & no ashes are present
 CheckForDestroy();
 RefreshFireplaceVisuals();
 }
 
 
 override void SetCookingEquipment(ItemBase equipment)
 {
 super.SetCookingEquipment(equipment);
 
 TripodBase stand = TripodBase.Cast(FindAttachmentBySlotName("CookingTripod"));
 if (stand)
 {
 if (equipment)
 stand.LockToParent();
 else
 stand.UnlockFromParent();
 }
 }
 
 override void OnBeforeTryDelete() 
 {
 super.OnBeforeTryDelete();
 
 MiscGameplayFunctions.DropAllItemsInInventoryInBounds(this, m_HalfExtents);
 }
 
 override bool IsPrepareToDelete()
 {
 return GetInventory().AttachmentCount() == 0 && !IsBurning() && !HasAshes();
 }
 
 //CONDITIONS
 //this into/outo parent.Cargo
 override bool CanPutInCargo(EntityAI parent)
 {
 if (!super.CanPutInCargo(parent))
 {
 return false;
 }
 
 if (HasAshes() || IsBurning() || HasStones() || HasStoneCircle() || IsOven() || !IsCargoEmpty() || HasCookingStand())
 {
 return false;
 }
 
 return true;
 }
 
 override bool CanRemoveFromCargo( EntityAI parent )
 {
 return true;
 }
 
 //cargo item into/outo this.Cargo
 override bool CanReceiveItemIntoCargo( EntityAI item )
 {
 if ( GetHierarchyParent() )
 return false;
 
 return super.CanReceiveItemIntoCargo( item );
 }
 
 override bool CanLoadItemIntoCargo( EntityAI item )
 {
 if (!super.CanLoadItemIntoCargo( item ))
 return false;
 
 if ( GetHierarchyParent() )
 return false;
 
 return true;
 }
 
 //hands
 override bool CanPutIntoHands(EntityAI parent)
 {
 if (!super.CanPutIntoHands(parent))
 {
 return false;
 }
 
 if (HasAshes() || IsBurning() || HasStones() || HasStoneCircle() || IsOven() || !IsCargoEmpty() || HasCookingStand())
 {
 return false;
 }
 
 return true;
 }
 
 override bool CanDisplayAttachmentCategory( string category_name )
 {
 if ( !super.CanDisplayAttachmentCategory( category_name ) )
 return false;
 
 if ( IsOven() )
 {
 if ( category_name == "CookingEquipment" )
 return false;
 if ( ( category_name == "DirectCooking" ) || ( category_name == "Smoking" ) )
 return true;
 }
 else
 {
 if ( category_name == "CookingEquipment" )
 return true;
 if ( ( category_name == "DirectCooking" ) || ( category_name == "Smoking" ) )
 return false;
 }
 return true;
 }
 
 override bool CanAssignAttachmentsToQuickbar()
 {
 return false;
 }
 
 override float HeightStartCheckOverride()
 {
 return 0.32;
 }
 
 //particles
 override bool CanShowSmoke()
 {
 return !IsOven();
 }
 
 
 void DestroyClutterCutter( Object clutter_cutter )
 {
 GetGame().ObjectDelete( clutter_cutter );
 }
 
 override void RefreshPhysics()
 {
 super.RefreshPhysics();
 
 //Oven
 if ( IsOven() )
 {
 RemoveProxyPhysics( ANIMATION_OVEN );
 AddProxyPhysics( ANIMATION_OVEN );
 }
 else
 {
 RemoveProxyPhysics( ANIMATION_OVEN );
 }
 
 //Tripod
 if ( IsItemTypeAttached( ATTACHMENT_TRIPOD ) )
 {
 RemoveProxyPhysics( ANIMATION_TRIPOD );
 AddProxyPhysics( ANIMATION_TRIPOD );
 }
 else
 {
 RemoveProxyPhysics( ANIMATION_TRIPOD );
 } 
 }
 
 override void RefreshFireplacePhysics()
 {
 RefreshPhysics();
 }
 
 //on store save/load
 override void OnStoreSave( ParamsWriteContext ctx )
 { 
 super.OnStoreSave(ctx);
 
 if ( GetGame().SaveVersion() >= 110 )
 {
 // save stone circle state
 ctx.Write( m_HasStoneCircle );
 
 // save stone oven state
 ctx.Write( m_IsOven );
 }
 }
 
 override bool OnStoreLoad( ParamsReadContext ctx, int version )
 {
 if ( !super.OnStoreLoad(ctx, version) )
 return false;
 
 if ( version >= 110 )
 {
 // read stone circle state
 if ( !ctx.Read( m_HasStoneCircle ) )
 {
 m_HasStoneCircle = false;
 return false;
 }
 // read stone oven state
 if ( !ctx.Read( m_IsOven ) )
 {
 m_IsOven = false;
 return false;
 }
 } 
 return true;
 }
 
 override void AfterStoreLoad()
 { 
 super.AfterStoreLoad();
 
 if ( IsBurning() )
 {
 if ( !m_ClutterCutter )
 {
 m_ClutterCutter = GetGame().CreateObjectEx( OBJECT_CLUTTER_CUTTER, GetPosition(), ECE_PLACE_ON_SURFACE );
 m_ClutterCutter.SetOrientation( GetOrientation() );
 }
 }
 }
 
 //================================================================
 // IGNITION ACTION
 //================================================================ 
 
 // Item-to-item fire distribution
 override bool HasFlammableMaterial()
 {
 return true;
 }
 
 override bool CanBeIgnitedBy(EntityAI igniter = NULL)
 {
 return HasAnyKindling() && !IsBurning() && !GetHierarchyParent();
 }
 
 override bool CanIgniteItem(EntityAI ignite_target = NULL)
 {
 return IsBurning();
 }
 
 override bool IsIgnited()
 {
 return IsBurning();
 }
 
 override void OnIgnitedTarget( EntityAI ignited_item )
 {
 }
 
 override void OnIgnitedThis( EntityAI fire_source )
 { 
 //remove grass
 Object cc_object = GetGame().CreateObjectEx( OBJECT_CLUTTER_CUTTER , GetPosition(), ECE_PLACE_ON_SURFACE );
 cc_object.SetOrientation ( GetOrientation() );
 GetGame().GetCallQueue( CALL_CATEGORY_GAMEPLAY ).CallLater( DestroyClutterCutter, 200, false, cc_object );
 
 //start fire
 StartFire();
 
 if ( fire_source )
 {
 Man player = fire_source.GetHierarchyRootPlayer();
 
 if ( player )
 {
 EFireIgniteType ignate_type = EFireIgniteType.Unknow;
 
 if ( fire_source.ClassName() == "Matchbox" )
 {
 ignate_type = EFireIgniteType.Matchbox;
 }
 else if ( fire_source.ClassName() == "Roadflare" )
 {
 ignate_type = EFireIgniteType.Roadflare;
 }
 else if ( fire_source.ClassName() == "HandDrillKit" )
 {
 ignate_type = EFireIgniteType.HandDrill;
 }
 
 
 SyncEvents.SendPlayerIgnatedFireplace( player, ignate_type );
 }
 }
 }
 
 override bool IsThisIgnitionSuccessful( EntityAI item_source = NULL )
 {
 SetIgniteFailure( false );
 Param1<bool> failure;
 
 //check kindling
 if ( !HasAnyKindling() )
 {
 return false;
 }
 
 //check roof
 if ( !IsOven() )
 {
 if ( !IsCeilingHighEnoughForSmoke() && IsOnInteriorSurface() )
 {
 return false;
 }
 }
 
 //check surface
 if ( IsOnWaterSurface() )
 {
 return false;
 }
 
 //check wetness
 if ( IsWet() )
 {
 SetIgniteFailure( true );
 
 failure = new Param1<bool>( GetIgniteFailure() );
 GetGame().RPCSingleParam( this, FirePlaceFailure.WET, failure, true );
 return false;
 }
 
 // check if the fireplace isnt below a roof
 // excluding this check whein oven stage
 if ( !IsOven() && !MiscGameplayFunctions.IsUnderRoof( this ) )
 {
 // if not, check if there is strong rain or wind
 if ( IsRainingAbove() )
 {
 SetIgniteFailure( true );
 
 failure = new Param1<bool>( GetIgniteFailure() );
 GetGame().RPCSingleParam( this, FirePlaceFailure.WET, failure, true );
 return false;
 }
 
 if ( IsWindy() )
 {
 SetIgniteFailure( true );
 
 failure = new Param1<bool>( GetIgniteFailure() );
 GetGame().RPCSingleParam( this, FirePlaceFailure.WIND, failure, true );
 return false;
 }
 }
 
 return true; 
 }
 
 //================================================================
 // FIREPLACE ENTITY
 //================================================================ 
 static Fireplace IgniteEntityAsFireplace( notnull EntityAI entity, notnull EntityAI fire_source )
 {
 //get player
 PlayerBase player = PlayerBase.Cast( fire_source.GetHierarchyRootPlayer() );
 
 //create fireplace
 Fireplace fireplace = Fireplace.Cast( GetGame().CreateObjectEx( "Fireplace" , entity.GetPosition(), ECE_PLACE_ON_SURFACE ) );
 
 //attach
 if ( !GetGame().IsMultiplayer() ) //clear inventory reservation (single player)
 {
 InventoryLocation loc = new InventoryLocation;
 entity.GetInventory().GetCurrentInventoryLocation( loc );
 player.GetInventory().ClearInventoryReservationEx( entity, loc );
 }
 
 if ( GetGame().IsServer() && GetGame().IsMultiplayer() )
 {
 player.ServerTakeEntityToTargetAttachment( fireplace, entity ); // multiplayer server side
 }
 else
 {
 player.LocalTakeEntityToTargetAttachment( fireplace, entity ); // single player or multiplayer client side
 }
 
 //start fire
 fireplace.StartFire();
 fireplace.OnIgnitedThis(fire_source);
 
 return fireplace;
 }
 
 static bool CanIgniteEntityAsFireplace(notnull EntityAI entity)
 {
 //check ceiling (enough space for smoke)
 if (MiscGameplayFunctions.IsUnderRoof(entity, FireplaceBase.MIN_CEILING_HEIGHT) && IsEntityOnInteriorSurface(entity))
 {
 return false;
 }
 
 //check surface
 if (FireplaceBase.IsEntityOnWaterSurface(entity))
 {
 return false;
 }
 
 if (!MiscGameplayFunctions.IsUnderRoof(entity))
 return !FireplaceBase.IsRainingAboveEntity(entity);
 
 return true; 
 }
 
 //================================================================
 // ADVANCED PLACEMENT
 //================================================================
 
 override string GetPlaceSoundset()
 {
 return "placeFireplace_SoundSet";
 }
 
 override void SetActions()
 {
 super.SetActions();
 
 AddAction(ActionPlaceFireplaceIntoBarrel);
 AddAction(ActionPlaceFireplaceIndoor);
 AddAction(ActionPlaceOvenIndoor);
 AddAction(ActionTogglePlaceObject);
 AddAction(ActionPlaceObject);
 AddAction(ActionBuildOven);
 AddAction(ActionDismantleOven);
 AddAction(ActionBuildStoneCircle);
 AddAction(ActionDismantleStoneCircle);
 }
}