hescobox.c

Go to the documentation of this file.

class HescoBox extends Inventory_Base
{
 static const int FOLDED = 0;
 static const int UNFOLDED = 1;
 static const int FILLED = 2;
 static const int PERCENTUAL_DAMAGE = 1;
 
 ref Timer m_Timer;
 ref protected EffectSound m_DeployLoopSound;
 
 protected int m_State;
 
 void HescoBox()
 {
 m_State = FOLDED;
 
 //synchronized variables
 RegisterNetSyncVariableInt( "m_State", FOLDED, FILLED );
 RegisterNetSyncVariableBool("m_IsSoundSynchRemote");
 RegisterNetSyncVariableBool("m_IsDeploySound");
 }
 
 void ~HescoBox()
 {
 SEffectManager.DestroyEffect( m_DeployLoopSound );
 }
 
 override bool HasProxyParts()
 {
 return true;
 }
 
 override bool CanPutIntoHands( EntityAI parent )
 {
 if( !super.CanPutIntoHands( parent ) )
 {
 return false;
 }
 return CanBeManipulated();
 }
 
 void Synchronize()
 {
 SetSynchDirty();
 }
 
 override void OnVariablesSynchronized()
 {
 super.OnVariablesSynchronized();
 
 //refresh visuals
 RefreshVisuals();
 
 if ( IsDeploySound() )
 {
 PlayDeploySound();
 }
 
 if ( CanPlayDeployLoopSound() )
 {
 PlayDeployLoopSound();
 }
 
 if ( m_DeployLoopSound && !CanPlayDeployLoopSound() )
 {
 StopDeployLoopSound();
 }
 }
 
 void RefreshVisuals()
 {
 }
 
 int GetState()
 {
 return m_State;
 }
 
 void SetState( int state )
 {
 m_State = state;
 }
 
 bool CanBeFilledAtPosition( vector position )
 {
 string surface_type;
 GetGame().SurfaceGetType( position[0], position[2], surface_type );
 
 return GetGame().IsSurfaceDigable(surface_type);
 }
 
 bool CanBeManipulated()
 {
 if ( GetState() == FOLDED )
 {
 return true;
 }
 else
 {
 return false;
 }
 }
 
 void Fold()
 {
 this.ShowSelection( "inventory" );
 this.HideSelection( "placing" );
 this.HideSelection( "filled" );
 
 SetState( FOLDED );
 RefreshPhysics();
 
 if ( GetGame().IsServer() )
 {
 SetAllowDamage(true);
 Synchronize();
 float fold_damage = ( GetMaxHealth( "", "" ) / 100 ) * PERCENTUAL_DAMAGE;
 DecreaseHealth( "", "", fold_damage );
 }
 }
 
 void Unfold()
 {
 this.HideSelection( "inventory" );
 this.ShowSelection( "placing" );
 this.HideSelection( "filled" );
 
 SetState( UNFOLDED );
 RefreshPhysics();
 
 if ( GetGame().IsServer() )
 {
 SetAllowDamage(true);
 Synchronize();
 float unfold_damage = ( GetMaxHealth( "", "" ) / 100 ) * PERCENTUAL_DAMAGE;
 DecreaseHealth( "", "", unfold_damage ); 
 }
 }
 
 override void EEItemLocationChanged (notnull InventoryLocation oldLoc, notnull InventoryLocation newLoc)
 {
 super.EEItemLocationChanged (oldLoc, newLoc);
 
 //RefreshPhysics();
 }
 
 override void RefreshPhysics()
 {
 super.RefreshPhysics();
 
 if ( this && !ToDelete() )
 {
 RemoveProxyPhysics( "inventory" );
 RemoveProxyPhysics( "placing" );
 RemoveProxyPhysics( "filled" );
 
 int state = GetState();
 
 switch (state)
 {
 case UNFOLDED:
 //ShowSelection( "placing" );
 AddProxyPhysics( "placing" ); 
 
 return;
 
 case FOLDED:
 AddProxyPhysics( "inventory" ); 
 return;
 
 case FILLED:
 AddProxyPhysics( "filled" ); 
 return;
 }
 }
 }
 
 void Fill()
 {
 this.HideSelection( "inventory" );
 this.HideSelection( "placing" );
 this.ShowSelection( "filled" );
 
 SetState( FILLED );
 RefreshPhysics();
 
 if ( GetGame().IsServer() )
 {
 Synchronize();
 DecreaseHealth( "", "", 5 ); //TODO Daniel implement soft skill bonus via useraction
 SetAllowDamage(false);
 }
 }
 
 override void OnStoreSave(ParamsWriteContext ctx)
 { 
 super.OnStoreSave(ctx);
 
 // Save state
 ctx.Write( m_State );
 }
 
 override bool OnStoreLoad(ParamsReadContext ctx, int version)
 { 
 if ( !super.OnStoreLoad(ctx, version) )
 return false;
 
 // Load folded/unfolded state
 int state = FOLDED;
 if ( !ctx.Read(state) )
 state = FOLDED;
 
 switch (state)
 {
 case FOLDED:
 {
 Fold();
 break;
 }
 case UNFOLDED:
 {
 Unfold();
 break;
 }
 case FILLED:
 {
 Fill();
 break;
 }
 }
 return true;
 }
 
 //================================================================
 // ADVANCED PLACEMENT
 //================================================================
 
 override void OnPlacementComplete( Man player, vector position = "0 0 0", vector orientation = "0 0 0" )
 {
 super.OnPlacementComplete( player, position, orientation );
 
 if ( GetGame().IsServer() )
 {
 Unfold();
 
 SetIsDeploySound( true );
 }
 }
 
 override bool IsDeployable()
 {
 return true;
 }
 
 override string GetDeploySoundset()
 {
 return "placeHescoBox_SoundSet";
 }
 
 override string GetLoopDeploySoundset()
 {
 return "hescobox_deploy_SoundSet";
 }
 
 void PlayDeployLoopSound()
 { 
 if ( !GetGame().IsDedicatedServer() )
 { 
 if ( !m_DeployLoopSound || !m_DeployLoopSound.IsSoundPlaying() )
 {
 m_DeployLoopSound = SEffectManager.PlaySound( GetLoopDeploySoundset(), GetPosition() );
 }
 }
 }
 
 void StopDeployLoopSound()
 {
 if ( !GetGame().IsDedicatedServer() )
 { 
 m_DeployLoopSound.SetSoundFadeOut(0.5);
 m_DeployLoopSound.SoundStop();
 }
 }
 
 override void SetActions()
 {
 super.SetActions();
 
 AddAction(ActionTogglePlaceObject);
 AddAction(ActionFoldObject);
 AddAction(ActionDeployObject);
 }
}