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