feat: Ability to limit turret firing arc

data/tooltips.txt

@@ -797,6 +797,9 @@ tip "shots / second:"
 tip "turret turn rate:"
 	`How fast this turret turns to track its targets, in degrees per second.`
 
+tip "arc:"
+	`The angular range of protection provided by this weapon, in degrees.`
+
 tip "homing:"
 	`How well this projectile tracks its target. Weapons with better homing can adjust to the target's speed to plot a more effective intercept course.`
 

source/AI.cpp

@@ -2908,7 +2908,9 @@ void AI::AimTurrets(const Ship &ship, FireCommand &command, bool opportunistic)
 			{
 				// Get the index of this weapon.
 				int index = &hardpoint - &ship.Weapons().front();
-				double offset = (hardpoint.HarmonizedAngle() - hardpoint.GetAngle()).Degrees();
+				Angle targetAngle = hardpoint.GetIdleAngle();
+				double offset = 0.;
+				offset = (targetAngle - hardpoint.GetAngle()).Degrees();
 				command.SetAim(index, offset / hardpoint.GetOutfit()->TurretTurn());
 			}
 		return;
@@ -2926,8 +2928,11 @@ void AI::AimTurrets(const Ship &ship, FireCommand &command, bool opportunistic)
 				if(!previous && (Random::Int(60)))
 					continue;
 
-				Angle centerAngle = Angle(hardpoint.GetPoint());
-				double bias = (centerAngle - hardpoint.GetAngle()).Degrees() / 180.;
+				Angle centerAngle = Angle(hardpoint.GetIdleAngle());
+				const Angle minArc = hardpoint.GetMinArc();
+				const Angle maxArc = hardpoint.GetMaxArc();
+				const auto arcMiddleDegrees = (minArc.AbsDegrees() + maxArc.AbsDegrees()) / 2.;
+				double bias = (centerAngle - hardpoint.GetAngle()).Degrees() / min(arcMiddleDegrees, 180.);
 				double acceleration = Random::Real() - Random::Real() + bias;
 				command.SetAim(index, previous + .1 * acceleration);
 			}
@@ -2974,7 +2979,32 @@ void AI::AimTurrets(const Ship &ship, FireCommand &command, bool opportunistic)
 				p += v * rendezvousTime;
 
 				// Determine how much the turret must turn to face that vector.
-				double degrees = (Angle(p) - aim).Degrees();
+				double degrees = 0.0;
+				Angle angleToPoint = Angle(p);
+				if(hardpoint.IsOmnidirectional())
+					degrees = (angleToPoint - aim).Degrees();
+				else
+				{
+					Angle minArc = hardpoint.GetMinArc();
+					Angle maxArc = hardpoint.GetMaxArc();
+					const Angle facing = ship.Facing();
+					minArc += facing;
+					maxArc += facing;
+					if(!angleToPoint.IsInRange(minArc, maxArc))
+					{
+						// Decrease the priority of the target.
+						rendezvousTime += 2. * weapon->TotalLifetime();
+
+						// Point to the nearer edge of the arc.
+						const double degree1 = (minArc - angleToPoint).Degrees();
+						const double degree2 = (maxArc - angleToPoint).Degrees();
+						if(fabs(degree1) < fabs(degree2))
+							angleToPoint = minArc;
+						else
+							angleToPoint = maxArc;
+					}
+					degrees = (angleToPoint - minArc).AbsDegrees() - (aim - minArc).AbsDegrees();
+				}
 				double turnTime = fabs(degrees) / weapon->TurretTurn();
 				// All bodies within weapons range have the same basic
 				// weight. Outside that range, give them lower priority.

source/Angle.cpp

@@ -22,6 +22,9 @@ this program. If not, see <https://www.gnu.org/licenses/>.
 #include <cmath>
 #include <cstdlib>
 #include <vector>
+#include <utility>
+
+using namespace std;
 
 namespace {
 	// Suppose you want to be able to turn 360 degrees in one second. Then you are
@@ -152,6 +155,14 @@ double Angle::Degrees() const
 
 
 
+// Convert an Angle object to degrees, in the range 0 to 360.
+double Angle::AbsDegrees() const
+{
+	return angle / DEG_TO_STEP;
+}
+
+
+
 // Return a point rotated by this angle around (0, 0).
 Point Angle::Rotate(const Point &point) const
 {
@@ -164,6 +175,26 @@ Point Angle::Rotate(const Point &point) const
 
 
 
+// Judge whether this is inside from "base" to "limit."
+// The range from "base" to "limit" is expressed by "clock" orientation.
+bool Angle::IsInRange(const Angle& base, const Angle& limit) const
+{
+	// Choose an edge of the arc as the reference angle (base) and
+	// compare relative angles to decide whether this is in the range.
+	Angle normalizedLimit = limit - base;
+	Angle normalizedTarget = *this - base;
+	return normalizedTarget.angle <= normalizedLimit.angle;
+}
+
+
+
+bool Angle::IsInRange(const pair<Angle, Angle>& range) const
+{
+	return IsInRange(range.first, range.second);
+}
+
+
+
 // Constructor using Angle's internal representation.
 Angle::Angle(int32_t angle)
 	: angle(angle)

source/Angle.h

@@ -19,6 +19,7 @@ this program. If not, see <https://www.gnu.org/licenses/>.
 #include "Point.h"
 
 #include <cstdint>
+#include <utility>
 
 
 
@@ -53,10 +54,18 @@ class Angle {
 	Point Unit() const;
 	// Convert an Angle object to degrees, in the range -180 to 180.
 	double Degrees() const;
+	// Convert an Angle object to degrees, in the range 0 to 360.
+	double AbsDegrees() const;
 
 	// Return a point rotated by this angle around (0, 0).
 	Point Rotate(const Point &point) const;
 
+	// Judge whether this is inside from "base" to "limit."
+	// The range from "base" to "limit" is expressed by "clock" orientation.
+	bool IsInRange(const Angle &base, const Angle &limit) const;
+	// The "range" is a pair of "base" and "limit."
+	bool IsInRange(const std::pair<Angle, Angle>& range) const;
+
 
 private:
 	explicit Angle(int32_t angle);

source/Armament.cpp

@@ -30,17 +30,19 @@ using namespace std;
 
 
 // Add a gun hardpoint (fixed-direction weapon).
-void Armament::AddGunPort(const Point &point, const Angle &angle, bool isParallel, bool isUnder, const Outfit *outfit)
+void Armament::AddGunPort(const Point &point, const Hardpoint::BaseAttributes &attributes,
+	bool isUnder, const Outfit *outfit)
 {
-	hardpoints.emplace_back(point, angle, false, isParallel, isUnder, outfit);
+	hardpoints.emplace_back(point, attributes, false, isUnder, outfit);
 }
 
 
 
-// Add a turret hardpoint (omnidirectional weapon).
-void Armament::AddTurret(const Point &point, bool isUnder, const Outfit *outfit)
+// Add a turret hardpoint.
+void Armament::AddTurret(const Point &point, const Hardpoint::BaseAttributes &attributes,
+	bool isUnder, const Outfit *outfit)
 {
-	hardpoints.emplace_back(point, Angle(0.), true, false, isUnder, outfit);
+	hardpoints.emplace_back(point, attributes, true, isUnder, outfit);
 }
 
 

source/Armament.h

@@ -43,8 +43,10 @@ class Visual;
 class Armament {
 public:
 	// Add a gun or turret hard-point.
-	void AddGunPort(const Point &point, const Angle &angle, bool isParallel, bool isUnder, const Outfit *outfit = nullptr);
-	void AddTurret(const Point &point, bool isUnder, const Outfit *outfit = nullptr);
+	void AddGunPort(const Point &point, const Hardpoint::BaseAttributes &attributes,
+		bool isUnder, const Outfit *outfit = nullptr);
+	void AddTurret(const Point &point, const Hardpoint::BaseAttributes &attributes,
+		bool isUnder, const Outfit *outfit = nullptr);
 	// This must be called after all the outfit data is loaded. If you add more
 	// of a given weapon than there are slots for it, the extras will not fire.
 	// But, the "gun ports" attribute should keep that from happening. To