Guards.c

class WeaponGuardBase class GuardAnd class GuardNot class GuardOr class WeaponGuardJammed class WeaponGuardIsDestroyed class WeaponGuardHasAmmo class WeaponGuardHasAmmoInnerMagazine class WeaponGuardHasAmmoInEvent class WeaponGuardHasMag class WeaponGuardChamberEmpty class WeaponGuardCurrentChamberEmpty class WeaponGuardAnyChamberEmpty class WeaponGuardChamberFull class WeaponGuardCurrentChamberFull class WeaponGuardInnerMagazineFull class WeaponGuardInnerMagazineFullShareChamber class WeaponGuardChamberFiredOut class WeaponGuardCurrentChamberFiredOut class WeaponGuardAnyChamberFiredOut class WeaponGuardCanAttachMag class WeaponGuardCanSwapMag class WeaponGuardCanDetachMag class WeaponGuardChamberHasRoomForMoreThanOne class WeaponGuardInternalMagazineHasRoomForBullet class WeaponGuardChamberHasRoomForOne class WeaponGuardChamberMultiHasRoomBulltet class WeaponGuardChamberMultiHasRoomBulltetIgnoreLast class WeaponGuardHasAmmoInLoopedState class WeaponGuardMagazinesHaveEqualSizes class WeaponGuardWeaponCharged class WeaponGuardWeaponDischarged class WeaponGuardWeaponOpen class WeaponGuardWeaponManagerWantContinue
/**@class	WeaponGuardBase
 * @brief	represents guard on a transition from state to state
 **/
class WeaponGuardBase
{
	/**@fn		GuardCondition
	 * @brief enable or disable transition based on condition
	 * the guard is a boolean operation executed first and which can prevent the transition from firing by returning false
	 * @return	true if transition is allowed
	 **/
	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();
	}
};