Guards.c

Go to the documentation of this file.

 
class WeaponGuardBase
{
  bool GuardCondition(WeaponEventBase e) { return true; }
};
 
class GuardAnd extends WeaponGuardBase
{
  ref WeaponGuardBase m_arg0;
  ref WeaponGuardBase m_arg1;
 
  void GuardAnd(WeaponGuardBase arg0 = NULL, WeaponGuardBase arg1 = NULL) { m_arg0 = arg0; m_arg1 = arg1; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    bool result = m_arg0.GuardCondition(e) && m_arg1.GuardCondition(e);
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] guard - " + m_arg0.Type() + " && " + m_arg1.Type() + " = " + result);
    return result;
  }
};
 
class GuardNot extends WeaponGuardBase
{
  ref WeaponGuardBase m_arg0;
 
  void GuardNot(WeaponGuardBase arg0 = NULL) { m_arg0 = arg0; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    bool result = !m_arg0.GuardCondition(e);
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] guard - ! " + m_arg0.Type() + " = " + result);
    return result;
  }
};
 
class GuardOr extends WeaponGuardBase
{
  ref WeaponGuardBase m_arg0;
  ref WeaponGuardBase m_arg1;
 
  void GuardOr(WeaponGuardBase arg0 = NULL, WeaponGuardBase arg1 = NULL) { m_arg0 = arg0; m_arg1 = arg1; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    bool result = m_arg0.GuardCondition(e) || m_arg1.GuardCondition(e);
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] guard - " + m_arg0.Type() + " || " + m_arg1.Type() + " = " + result);
    return result;
  }
};
 
// guards /////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
class WeaponGuardJammed extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardJammed(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    /*int mi = m_weapon.GetCurrentMuzzle();
      if (m_weapon.IsChamberJammed(mi))*/
    if (m_weapon.IsJammed())
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - jammed");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] guard - not jammed");
    return false;
  }
};
 
class WeaponGuardIsDestroyed extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardIsDestroyed(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    if (m_weapon.IsDamageDestroyed())
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - weapon destroyed");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - weapon not destroyed");
    return false;
  }
}
 
class WeaponGuardHasAmmo extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardHasAmmo(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    Magazine mag = m_weapon.GetMagazine(mi);
    if (mag != NULL && mag.GetAmmoCount() > 0)
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - has ammo");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - no ammo");
    return false;
  }
};
 
class WeaponGuardHasAmmoInnerMagazine extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardHasAmmoInnerMagazine(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    if (m_weapon.GetInternalMagazineCartridgeCount(mi) >= 1)
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - has ammo in inner magazine");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - no ammo in inner magazine");
    return false;
  }
};
 
class WeaponGuardHasAmmoInEvent extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardHasAmmoInEvent(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    Magazine mag = e.m_magazine;
    if (mag != NULL && mag.GetAmmoCount() > 0)
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - has ammo in event");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - no ammo in event");
    return false;
  }
};
 
 
class WeaponGuardHasMag extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardHasMag(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    Magazine mag = m_weapon.GetMagazine(mi);
    if (mag != NULL)
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - has magazine");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - no magazine");
    return false;
  }
};
 
class WeaponGuardChamberEmpty extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  protected int m_muzzle;
  void WeaponGuardChamberEmpty(Weapon_Base w = NULL, int muzzle_index = 0) { m_weapon = w; m_muzzle = muzzle_index; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    if (m_weapon.IsChamberEmpty(m_muzzle))
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber (" + m_muzzle + ") empty");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber (" + m_muzzle + ") not empty");
    return false;
  }
};
 
class WeaponGuardCurrentChamberEmpty extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardCurrentChamberEmpty(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    if (m_weapon.IsChamberEmpty(mi))
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber empty");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber not empty");
    return false;
  }
};
 
class WeaponGuardAnyChamberEmpty extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  protected int m_muzzle;
  void WeaponGuardAnyChamberEmpty(Weapon_Base w = NULL, int muzzle_index = 0) { m_weapon = w; m_muzzle = muzzle_index; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    for (int i = 0; i < m_weapon.GetMuzzleCount(); i++)
    {
      if (m_weapon.IsChamberEmpty(i))
      {
        if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - multi chamber (" + i + ") empty");
        return true;
      }
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - no chamber empty");
    return false;
  }
};
 
class WeaponGuardChamberFull extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  protected int m_muzzle;
  void WeaponGuardChamberFull(Weapon_Base w = NULL, int muzzle_index = 0) { m_weapon = w; m_muzzle = muzzle_index; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    if (m_weapon.IsChamberFull(m_muzzle))
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber (" + m_muzzle + ") full");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber (" + m_muzzle + ") not full");
    return false;
  }
};
 
class WeaponGuardCurrentChamberFull extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardCurrentChamberFull(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    if (m_weapon.IsChamberFull(mi))
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber full");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber not full");
    return false;
  }
};
 
 
class WeaponGuardInnerMagazineFull extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardInnerMagazineFull(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    if (m_weapon.IsInternalMagazineFull(mi))
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - internal magazine full");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - internal magazine not full");
    return false;
  }
};
 
class WeaponGuardInnerMagazineFullShareChamber extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardInnerMagazineFullShareChamber(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
 
    if (m_weapon.IsChamberFull(mi) && m_weapon.IsInternalMagazineFull(mi))
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - internal magazine with share chamber is full");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - internal magazine with share chamber is not full");
    return false;
  }
};
 
class WeaponGuardChamberFiredOut extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  protected int m_muzzle;
  void WeaponGuardChamberFiredOut(Weapon_Base w = NULL, int muzzle_index = 0) { m_weapon = w; m_muzzle = muzzle_index; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    if (m_weapon.IsChamberFiredOut(m_muzzle))
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber (" + m_muzzle + ") fireout");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber (" + m_muzzle + ") not fireout");
    return false;
  }
};
 
class WeaponGuardCurrentChamberFiredOut extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardCurrentChamberFiredOut(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    if (m_weapon.IsChamberFiredOut(mi))
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber fired out");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber not fired out");
    return false;
  }
};
 
class WeaponGuardAnyChamberFiredOut extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardAnyChamberFiredOut(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    for (int i = 0; i < m_weapon.GetMuzzleCount(); i++)
    {
      if (m_weapon.IsChamberFiredOut(i))
      {
        if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - multi chamber (" + i + ") fired out");
        return true;
      }
    }
 
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - any chamber has not fired out");
    return false;
  }
};
 
class WeaponGuardCanAttachMag extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardCanAttachMag(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    if (m_weapon && e.m_magazine && m_weapon.CanAttachMagazine(mi, e.m_magazine))
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - can attach magazine");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - cannot attach magazine");
    return false;
  }
};
 
class WeaponGuardCanSwapMag extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardCanSwapMag(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    Magazine attached_mag = m_weapon.GetMagazine(mi);
    if (m_weapon && e.m_magazine && e.m_magazine != attached_mag /*&& m_weapon.CanSwapMagazine(mi, e.m_magazine)*/)
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - can swap magazine");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - cannot swap magazine");
    return false;
  }
};
 
class WeaponGuardCanDetachMag extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardCanDetachMag(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    if (m_weapon && e.m_magazine && m_weapon.GetMagazine(mi)/* && m_weapon.CanDetachMagazine(mi, e.m_magazine)*/)
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - can detach magazine");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - cannot detach magazine");
    return false;
  }
};
 
class WeaponGuardChamberHasRoomForMoreThanOne extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardChamberHasRoomForMoreThanOne(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    if (m_weapon.GetInternalMagazineMaxCartridgeCount(mi) - m_weapon.GetInternalMagazineCartridgeCount(mi) > 1)
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber has room for more than 1b");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber has no room for more than 1b");
    return false;
  }
};
 
class WeaponGuardInternalMagazineHasRoomForBullet extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardInternalMagazineHasRoomForBullet(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    if (m_weapon.GetInternalMagazineMaxCartridgeCount(mi) - m_weapon.GetInternalMagazineCartridgeCount(mi) >= 1)
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber has room for bullet");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber has no room for bullet");
    return false;
  }
};
 
class WeaponGuardChamberHasRoomForOne extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardChamberHasRoomForOne(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    if (m_weapon.GetTotalMaxCartridgeCount(mi) - m_weapon.GetTotalCartridgeCount(mi) == 1)
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber has room for 1b");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber has no room for 1b");
    return false;
  }
};
 
class WeaponGuardChamberMultiHasRoomBulltet extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardChamberMultiHasRoomBulltet(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int i = m_weapon.GetMuzzleCount() - 1;
    for (; i >= 0; i--)
    {
      if (m_weapon.GetTotalMaxCartridgeCount(i) - m_weapon.GetTotalCartridgeCount(i) >= 1)
      {
        if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber has room for 1b");
        return true;
      }
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber has no room for 1b");
    }
    return false;
  }
};
 
class WeaponGuardChamberMultiHasRoomBulltetIgnoreLast extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardChamberMultiHasRoomBulltetIgnoreLast(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int i = m_weapon.GetMuzzleCount() - 1;
    bool emty_one = false;
    for (; i >= 0; i--)
    {
      if (m_weapon.GetTotalMaxCartridgeCount(i) - m_weapon.GetTotalCartridgeCount(i) >= 1)
      {
        if (!emty_one)
          emty_one = true;
        else
        {
          if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber has room for 1b");
          return true;
        }
      }
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - chamber has no room for 1b");
    }
    return false;
  }
};
 
 
class WeaponGuardHasAmmoInLoopedState extends WeaponGuardBase
{
  WeaponChambering_Base m_state;
  void WeaponGuardHasAmmoInLoopedState(WeaponChambering_Base state) { m_state = state; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    Magazine mag = m_state.m_srcMagazine;
    if (mag != NULL && mag.GetAmmoCount() > 0)
    {
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] guard - has ammo in looped state");
      return true;
    }
    if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] guard - no ammo in looped state");
    return false;
  }
};
 
class WeaponGuardMagazinesHaveEqualSizes extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
  void WeaponGuardMagazinesHaveEqualSizes(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    int mi = m_weapon.GetCurrentMuzzle();
    Magazine mag = m_weapon.GetMagazine(mi);
    Magazine mag2 = e.m_magazine;
    if (mag != NULL && mag2 != NULL)
    {
      bool eq = magazinesHaveEqualSizes(mag, mag2);
      if (eq)
      {
        if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - same inventory sizes");
        return true;
      }
 
      if (LogManager.IsWeaponLogEnable()) wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - different inventory sizes");
      return false;
    }
    Error("[wpnfsm] " + Object.GetDebugName(m_weapon) + " guard - mag == NULL or mag2 == NULL, cannot perform comparison");
    return false;
  }
};
 
class WeaponGuardWeaponCharged extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
 
  void WeaponGuardWeaponCharged(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    return m_weapon.IsCharged();
  }
}
 
class WeaponGuardWeaponDischarged extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
 
  void WeaponGuardWeaponDischarged(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    return !m_weapon.IsCharged();
  }
}
 
class WeaponGuardWeaponOpen extends WeaponGuardBase
{
  protected Weapon_Base m_weapon;
 
  void WeaponGuardWeaponOpen(Weapon_Base w = NULL) { m_weapon = w; }
 
  override bool GuardCondition(WeaponEventBase e)
  {
    return m_weapon.IsWeaponOpen();
  }
}
 
 
class WeaponGuardWeaponManagerWantContinue extends WeaponGuardBase
{
  override bool GuardCondition(WeaponEventBase e)
  {
    PlayerBase player = PlayerBase.Cast(e.m_player);
    return player.GetWeaponManager().WantContinue();
  }
};