private static float GetAngle(Dot dot1, Dot dot2)
{
float dx = dot2.X - dot1.X;
float dy = dot2.Y - dot1.Y;
return(MathF.Atan2(dy, dx));
}
private void FireRocket()
{
bool found = false;
Vector3 pos = Transform.Pos;
Vector3 targetPos = new Vector3(float.MaxValue, float.MaxValue, pos.Z);
List <Player> players = api.Players;
for (int i = 0; i < players.Count; i++)
{
Vector3 newPos = players[i].Transform.Pos;
if ((pos - newPos).Length < (pos - targetPos).Length)
{
targetPos = newPos;
found = true;
}
}
if (found)
{
Vector3 diff = (targetPos - pos).Normalized;
Rocket rocket = new Rocket();
rocket.OnActivated(new ActorActivationDetails {
Api = api,
Pos = new Vector3(pos.X + (IsFacingLeft ? 10f : -10f), pos.Y + 10f, pos.Z - 2f)
});
rocket.Transform.Angle = MathF.Atan2(diff.Y, diff.X);
api.AddActor(rocket);
}
}
public override void Tick()
{
DronePawn target = (Local.Pawn as DronePawn).Target;
bool active = target != null;
SetClass("active", active);
if (active)
{
PositionAtWorld(target.Position);
Vector3 start = target.Position;
Vector3 lead = target.Position + (target.Velocity * TimeToTarget(target.Position));
Vector2 screen = lead.ToScreen() - start.ToScreen();
Style.Width = Length.Fraction(screen.Length);
float rot = MathF.Atan2(screen.y, screen.x).RadianToDegree();
PanelTransform transform = new PanelTransform();
transform.AddRotation(0, 0, rot);
Style.Transform = transform;
Style.Dirty();
}
}
public EntityMagicWeapon(Vector pnt, Tile[] obj, byte[,,] chips, EntityList par)
{
Location = pnt;
Mpts = obj;
Map = chips;
Parent = par;
Size = new Size(8, 8);
SetGraphic(2);
// ウェポンは同時に3つまでしか打てない
if (Parent.FindEntitiesByType <EntityMagicWeapon>().Count() > 3)
{
Kill();
}
// 対象を探す
// 条件は、プレイヤーに最も近い生きているエネミー
Entity?target = Parent
.Where(e => e.MyGroup == EntityGroup.Enemy)
.Where(e => !(e is EntityLiving l) || !l.IsDying)
.OrderBy(e => MathF.Abs(e.Location.Distance(Location)))
.FirstOrDefault();
// 対象がいればその方向へ、いなければランダムに射出
var r = target != null
? MathF.Atan2(Location.Y - target.Location.Y, Location.X - target.Location.X)
: DFMath.ToRadian(Core.GetRand(360));
Velocity = new Vector(MathF.Cos(r), MathF.Sin(r)) * -5;
}
public static Vector3 ToEuler(Quaternion q)
{
Vector3 angles = new Vector3();
// roll (X-axis rotation)
float sr_cp = 2.0f * (q.W * q.X + q.Y * q.Z);
float cr_cp = 1.0f - 2.0f * (q.X * q.X + q.Y * q.Y);
angles.Z = MathF.Atan2(sr_cp, cr_cp);
// pitch (Y-axis rotation)
float sp = 2.0f * (q.W * q.Y - q.Z * q.X);
if (MathF.Abs(sp) >= 1.0f)
{
angles.X = MathF.CopySign(GameSettings.PI_HALF, sp); // use 90 degrees if out of range
}
else
{
angles.X = MathF.Asin(sp);
}
// yaw (Z-axis rotation)
float sy_cp = 2.0f * (q.W * q.Z + q.X * q.Y);
float cy_cp = 1.0f - 2 * (q.Y * q.Y + q.Z * q.Z);
angles.Y = MathF.Atan2(sy_cp, cy_cp);
return(angles);
}
private void FollowNearestPlayer()
{
bool found = false;
Vector3 pos = Transform.Pos;
Vector3 targetPos = new Vector3(float.MaxValue, float.MaxValue, pos.Z);
List <Player> players = api.Players;
for (int i = 0; i < players.Count; i++)
{
Vector3 newPos = players[i].Transform.Pos;
if ((pos - newPos).Length < (pos - targetPos).Length)
{
targetPos = newPos;
found = true;
}
}
if (found)
{
Vector3 diff = (targetPos - pos).Normalized;
Vector3 speed = (new Vector3(speedX, speedY, 0f) + diff * 0.8f).Normalized;
speedX = speed.X * 5f;
speedY = speed.Y * 5f;
Transform.Angle = MathF.Atan2(speedY, speedX);
}
}
public Vector2 GetCurrentSample(Agent agent)
{
int commonSampleCount = this.layerCount * this.outerLayerSampleCount;
Vector2 oldVelocity = agent.SuggestedVel / agent.Characteristics.MaxSpeed;
// this can happen if the max speed changed during the last update
if (oldVelocity.LengthSquared > 1f)
{
oldVelocity.Normalize();
}
if (this.currentSampleIdx >= commonSampleCount + 1)
{
return(Vector2.Zero);
}
if (this.currentSampleIdx >= commonSampleCount)
{
return(oldVelocity);
}
int layerIdx = this.currentSampleIdx % this.layerCount;
int directionIdx = (this.currentSampleIdx / this.layerCount) % this.outerLayerSampleCount;
float undistortedSpeedFactor = (float)(layerIdx + 1) / this.layerCount;
float undistortedAngle = MathF.Lerp(-1.0f, 1.0f, ((float)directionIdx / this.outerLayerSampleCount));
float speedFactor = undistortedSpeedFactor;
float angle = MathF.Atan2(oldVelocity.Y, oldVelocity.X) + MathF.Pow(Math.Abs(undistortedAngle), 0.8f) * undistortedAngle * MathF.RadAngle180;
return(new Vector2(MathF.Cos(angle) * speedFactor, MathF.Sin(angle) * speedFactor));
}
protected override Task AliveAsync()
{
// await base.AliveAsync();
foreach (var sensor in Sensors)
{
sensor.Sense();
}
var contexts = ContextBehaviors.Select(b => b.Behave(Steps)).ToList();
(var finalRing, var angle, var boost) = ContextRingBlending.Blend(contexts, true);
SteerAngle(angle);
var willShoot = CanShoot;
if (CanBoost && boost && (this.SensorFleets.MyFleet?.Ships.Count ?? 0) > BoostThreshold)
{
if (ShootUntil < GameTime)
{
Boost();
}
willShoot = false;
}
if (CanShoot && willShoot)
{
var target = (AttackFleets ? FleetTargeting.ChooseTarget() : null)
?? (AttackAbandoned ? AbandonedTargeting.ChooseTarget() : null)
?? (AttackFish ? FishTargeting.ChooseTarget() : null);
if (target != null)
{
var shootAngle = MathF.Atan2(target.Position.Y - this.Position.Y, target.Position.X - this.Position.X);
bool dangerous = false;
if (!AttackFleets && this.SensorFleets.MyFleet != null)
{
var flets = FleetTargeting.PotentialTargetFleets();
foreach (var flet in flets)
{
if (RoboMath.MightHit(this.HookComputer, this.SensorFleets.MyFleet, flet, shootAngle))
{
dangerous = true;
}
}
}
if (!Safe || !dangerous)
{
ShootAt(target.Position);
}
}
}
if (ReloadConfigAfter > 0 && ReloadConfigAfter < GameTime)
{
LoadConfig();
ReloadConfigAfter = 0;
}
return(Task.FromResult(0));
}
void RotateToDirection(Vector3 dir)
{
dir.Y = 0;
Vector3 look = new Vector3(Node.GetTransform.GlobalTransform.M31, Node.GetTransform.GlobalTransform.M32, Node.GetTransform.GlobalTransform.M33);
look.Normalize();
Vector3 axis = Vector3.Cross(look, dir);
float dot = Vector3.Dot(dir, look);
float angle = MathF.Atan2(axis.Length, dot);
if (MathF.Abs(angle) < roteteSpeed)
{
IsRotating = false;
if (direction == targetDirection)
{
targetDirection = Vector3.Zero;
IsTaskCompleted = true;
OnComplete?.Invoke();
}
}
else
{
angle = (angle < 0) ? -roteteSpeed : roteteSpeed;
}
var rotation = Quaternion.FromAxisAngle(axis, angle);
Node.GetTransform.RotationQuaternion *= rotation;
}
public static (float, float, float) GetYawPitchRoll(this Quaternion q)
{
// roll (x-axis rotation)
var sinr_cosp = +2f * (q.W * q.X + q.Y * q.Z);
var cosr_cosp = +1f - 2f * (q.X * q.X + q.Y * q.Y);
var roll = MathF.Atan2(sinr_cosp, cosr_cosp);
// pitch (y-axis rotation)
float pitch;
var sinp = +2f * (q.W * q.Y - q.Z * q.X);
if (MathF.Abs(sinp) >= 1)
{
pitch = MathF.Sign(sinp) * MathF.PI / 2; // use 90 degrees if out of range
}
else
{
pitch = MathF.Asin(sinp);
}
// yaw (z-axis rotation)
var siny_cosp = +2f * (q.W * q.Z + q.X * q.Y);
var cosy_cosp = +1f - 2f * (q.Y * q.Y + q.Z * q.Z);
var yaw = MathF.Atan2(siny_cosp, cosy_cosp);
return(yaw, pitch, roll);
}
public override void ShootAt(Vector2 target)
{
var angle = MathF.Atan2(target.Y, target.X);
var canShoot = true;
if (this.firstRow != null)
{
var ddd = (int)MathF.Floor(((angle + 360.0f) % 360.0f) / 360.0f * (firstRow.Count - 1.0f));
if (ddd < 0)
{
ddd = 0;
}
if (ddd < firstRow.Count - 1)
{
(var d, var c) = firstRow[ddd].bestChildScorePath();
if (d[d.Count - 1].Fleet.Ships.Count < 1)
{
canShoot = false;
}
}
}
var mag = target.Length();
var r = new Random();
angle += (float)r.NextDouble() * TargetingAverageError * 2;
if (canShoot)
{
base.ShootAt(new Vector2(MathF.Cos(angle), MathF.Sin(angle)) * mag);
}
}
public static void Update()
{
for (uint i = 0; i < MaxZombies; i++)
{
if (Active[i])
{
int closeP = -1;
float closePD = float.MaxValue;
for (int j = 0; j < Players.MaxPlayers; j++)
{
float d = Vector2.DistanceSquared(Players.Bodies[j].Position, Bodies[i].Position);
if (d < closePD)
{
closePD = d;
closeP = j;
}
}
if (closeP != -1 && Data.World.RayCast(Bodies[i].Position, Players.Bodies[closeP].Position).FirstOrDefault() == Players.Bodies[closeP].FixtureList.FirstOrDefault())
{
float a = MathF.Atan2(Players.Bodies[closeP].Position.Y - Bodies[i].Position.Y, Players.Bodies[closeP].Position.X - Bodies[i].Position.X);
Angles[i] = Functions.LerpAngle(Angles[i], a, .05f);
Bodies[i].ApplyForce(new Vector2(MathF.Cos(a) * MoveSpeed, MathF.Sin(a) * MoveSpeed));
}
}
}
}
private void assertDirections()
{
AddAssert("group directions are correct", () =>
{
for (int i = 0; i < hitObjectContainer.Count; i++)
{
DrawableOsuHitObject expectedStart = getObject(i);
DrawableOsuHitObject expectedEnd = i < hitObjectContainer.Count - 1 ? getObject(i + 1) : null;
if (expectedEnd == null)
{
continue;
}
var manualClock = new ManualClock();
followPointRenderer.Clock = new FramedClock(manualClock);
manualClock.CurrentTime = expectedStart.HitObject.StartTime;
followPointRenderer.UpdateSubTree();
var points = getGroup(i).ChildrenOfType <FollowPoint>().ToArray();
if (points.Length == 0)
{
continue;
}
float expectedDirection = MathF.Atan2(expectedStart.Position.Y - expectedEnd.Position.Y, expectedStart.Position.X - expectedEnd.Position.X);
float realDirection = MathF.Atan2(expectedStart.Position.Y - points[^ 1].Position.Y, expectedStart.Position.X - points[^ 1].Position.X);
public static float GetWorldRotation(this Vector2 directionalVector)
{
var angle = MathF.Atan2(directionalVector.X, directionalVector.Y) + ToRadians(135);
angle = NormalizeRadians(angle);
return(angle);
}
private void Flock()
{
var oobVectorWeight = 0.2f;
var ships = World.BodiesNear(Position, World.Hook.FlockCohesionMaximumDistance)
.OfType <Ship>();
var flockingVector = Vector2.Zero;
var oobVector = Vector2.Zero;
if (ships.Count() > 1)
{
flockingVector =
(World.Hook.FlockCohesion
* Flocking.Cohesion(ships, this, World.Hook.FlockCohesionMaximumDistance))
+ (World.Hook.FlockAlignment
* Flocking.Alignment(ships, this))
+ (World.Hook.FlockSeparation
* Flocking.Separation(ships, this, World.Hook.FlockSeparationMinimumDistance));
}
if (IsOOB)
{
if (Position != Vector2.Zero)
{
oobVector = Vector2.Normalize(-Position) * oobVectorWeight;
}
}
var steeringVector =
new Vector2(MathF.Cos(Angle), MathF.Sin(Angle))
+ World.Hook.FlockWeight * flockingVector
+ oobVector;
Angle = MathF.Atan2(steeringVector.Y, steeringVector.X);
}
public bool PosTest3()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest3: Verify the angle of arctan(x,y) when the point in forward direction of X axis...");
try
{
float x = TestLibrary.Generator.GetSingle(-55);
while (x <= 0)
{
x = TestLibrary.Generator.GetSingle(-55);
}
float y = 0;
float angle = MathF.Atan2(y, x);
if (!MathFTestLib.SingleIsWithinEpsilon(angle, 0.0f))
{
TestLibrary.TestFramework.LogError("005", "The angle should be zero,actual: " + angle.ToString());
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("006", "Unexpected exception occurs: " + e);
retVal = false;
}
return(retVal);
}
public static TriggerVolume FromScenarioTriggerVolume(ScenarioTag tag, ScenarioTag.TriggerVolume tvDefinition)
{
var ent = new TriggerVolume();
ent.FriendlyName = tvDefinition.Description;
var orient = GetOrientation(tvDefinition.Orientation, tvDefinition.OrientationAxis);
var xform = new TransformComponent(ent, tvDefinition.Position, orient);
var renderModel = ModelFactory.Cuboid(Vector3.Zero, tvDefinition.Size, new Vector4(1f, 1f, 0f, 0.5f));
renderModel.Flags = ModelFlags.IsTransparent;
renderModel.RenderLayer = RenderLayers.Scripting;
var wireframeRenderModel = ModelFactory.Cuboid(Vector3.Zero, tvDefinition.Size, new Vector4(1f, 1f, 0f, 1f));
wireframeRenderModel.Flags = ModelFlags.Wireframe;
wireframeRenderModel.RenderLayer = RenderLayers.Scripting;
ent.SetComponents(xform,
TriggerGeometryComponent.Cuboid(ent, xform, tvDefinition.Size, tvDefinition.Description),
new RenderModelComponent(ent, renderModel),
new RenderModelComponent(ent, wireframeRenderModel));
return(ent);
Quaternion GetOrientation(Vector3 angle, Vector3 axis)
{
//BUG? The Z value of the angle vector is not used here, and is present in ~5 triggers in the game
var a = MathF.Atan2(angle.Y, angle.X);
return(Quaternion.CreateFromAxisAngle(axis, a));
}
}
public bool PosTest5()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest5: Verify the angle of arctan(x,y) when the point in negative direction of Y axis...");
try
{
float x = 0;
float y = TestLibrary.Generator.GetSingle(-55);
while (y >= 0)
{
y = -TestLibrary.Generator.GetSingle(-55);
}
float angle = MathF.Atan2(y, x);
if (!MathFTestLib.SingleIsWithinEpsilon(angle, -MathF.PI / 2))
{
TestLibrary.TestFramework.LogError("009", "The angle should be -pi/2, actual: " + angle.ToString());
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("010", "Unexpected exception occurs: " + e);
retVal = false;
}
return(retVal);
}
protected override void PreSweep(ContextRing ring)
{
base.PreSweep(ring);
AverageAngle = null;
if (LocalTeammates.Any())
{
int count = 0;
var averageMomentum = Vector2.Zero;
foreach (var fleet in LocalTeammates)
{
var distance = Vector2.Distance(fleet.Center, this.Robot.Position);
if (distance >= MinimumRange && distance <= MaximumRange)
{
averageMomentum += fleet.Momentum;
count++;
}
}
if (count > 0)
{
averageMomentum /= count;
AverageAngle = MathF.Atan2(averageMomentum.Y, averageMomentum.X);
}
}
}
public bool PosTest2()
{
bool retVal = true;
TestLibrary.TestFramework.BeginScenario("PosTest2: Verify the angle of arctan(x,y) when the point in quadrant four...");
try
{
float x = TestLibrary.Generator.GetSingle(-55);
while (x <= 0)
{
x = TestLibrary.Generator.GetSingle(-55);
}
float y = TestLibrary.Generator.GetSingle(-55);
while (y >= 0)
{
y = -TestLibrary.Generator.GetSingle(-55);
}
float angle = MathF.Atan2(y, x);
if (angle > 0 || angle < -MathF.PI / 2)
{
TestLibrary.TestFramework.LogError("003", "The angle should be between 0 and -MathF.PI/2, actual: " +
angle.ToString());
retVal = false;
}
}
catch (Exception e)
{
TestLibrary.TestFramework.LogError("004", "Unexpected exception occurs: " + e);
retVal = false;
}
return(retVal);
}
public float GetAbsoluteAngle(float x, float y)
{
float dx = x - GetPositionX();
float dy = y - GetPositionY();
return(NormalizeOrientation(MathF.Atan2(dy, dx)));
}
public static void Snake(Ship ship)
{
var hook = ship.World.Hook;
var fleet = ship.Fleet;
if (hook.SnakeWeight == 0)
{
return;
}
if (fleet == null || fleet.Ships.Count < 2)
{
return;
}
var shipIndex = fleet.Ships.IndexOf(ship);
if (shipIndex > 0)
{
ship.Size = 70;
var steeringVector = new Vector2(MathF.Cos(ship.Angle), MathF.Sin(ship.Angle));
steeringVector += (fleet.Ships[shipIndex - 1].Position - ship.Position) * hook.SnakeWeight;
ship.Angle = MathF.Atan2(steeringVector.Y, steeringVector.X);
}
else
{
ship.Size = 100;
}
}
public bool IsSafeTarget(Vector2 target)
{
var toTarget = target - Robot.Position;
var angle = MathF.Atan2(toTarget.Y, toTarget.X);
return(IsSafeShot(angle));
}
private float AngleBetween(PointF junction, PointF a, PointF b)
{
PointF vA = a - junction;
PointF vB = b - junction;
return(MathF.Atan2(vB.Y, vB.X) - MathF.Atan2(vA.Y, vA.X));
}
private static Vector3 MatrixToEuler(Matrix3x3 matrix)
{
// from http://www.geometrictools.com/Documentation/EulerAngles.pdf
// YXZ order
Vector3 v = Vector3.Zero;
if (matrix.Data[7] < 0.999F) // some fudge for imprecision
{
if (matrix.Data[7] > -0.999F) // some fudge for imprecision
{
v.X = MathF.Asin(-matrix.Data[7]);
v.Y = MathF.Atan2(matrix.Data[6], matrix.Data[8]);
v.Z = MathF.Atan2(matrix.Data[1], matrix.Data[4]);
MakePositive(v);
}
else
{
// WARNING. Not unique. YA - ZA = atan2(r01,r00)
v.X = MathF.PI * 0.5F;
v.Y = MathF.Atan2(matrix.Data[3], matrix.Data[0]);
v.Z = 0.0F;
MakePositive(v);
}
}
else
{
// WARNING. Not unique. YA + ZA = atan2(-r01,r00)
v.X = -MathF.PI * 0.5F;
v.Y = MathF.Atan2(-matrix.Data[3], matrix.Data[0]);
v.Z = 0.0F;
MakePositive(v);
}
return(v); //返回的是弧度值
}
public static float SignedAngle(Vector3 v1, Vector3 v2, Vector3 reference)
{
var c = Vector3.Cross(v1, v2);
var angle = MathF.Atan2(c.Length(), Vector3.Dot(v1, v2));
return(Vector3.Dot(c, reference) < 0 ? -angle : angle);
}
static PreyCaptureWorld()
{
// Calculate the size of the required lookup table. The table is a square matrix, and 'size' here is the
// number of matrix rows and columns.
// The matrix is used to lookup precomputed values of atan2(y, x) for some coordinate on the grid, relative to
// some other coordinate on the grid. Therefore the extremes of relative coordinates are (for a grid of size 24):
//
// (23,23) top right.
// (23,-23) bottom right.
// (-23, -23) bottom left.
// (-23, 23) top left.
//
// Hence the lookup table size is (2 * gridSize) - 1.
//
// Note. Given that the array indexes must begin with zero, the lookup table element at index [0,0] represents
// relative XY coordinate (-23,-23).
int size = (__gridSize * 2) - 1;
__atan2Lookup = new float[size, size];
for (int y = 0; y < size; y++)
{
for (int x = 0; x < size; x++)
{
__atan2Lookup[y, x] = MathF.Atan2(y - __atan2LookupOffset, x - __atan2LookupOffset);
}
}
}
private static void DrawArrow(
GeometrySink sink,
ReadOnlySpan <ImmutableVec2_float> bezier,
float arrowSize)
{
var b1X = BiaNodeEditorHelper.Bezier(bezier[0].X, bezier[1].X, bezier[2].X, bezier[3].X, 0.5001f);
var b1Y = BiaNodeEditorHelper.Bezier(bezier[0].Y, bezier[1].Y, bezier[2].Y, bezier[3].Y, 0.5001f);
var b2X = BiaNodeEditorHelper.Bezier(bezier[0].X, bezier[1].X, bezier[2].X, bezier[3].X, 0.5f);
var b2Y = BiaNodeEditorHelper.Bezier(bezier[0].Y, bezier[1].Y, bezier[2].Y, bezier[3].Y, 0.5f);
var sx = b1X - b2X;
var sy = b1Y - b2Y;
var r = MathF.Atan2(sy, sx) + MathF.PI * 0.5f;
var m = (MathF.Sin(r), MathF.Cos(r));
var l1 = new ImmutableVec2_float(arrowSize / 1.732f, arrowSize / 1.732f * 2.0f);
var l2 = new ImmutableVec2_float(-arrowSize / 1.732f, arrowSize / 1.732f * 2.0f);
var t1X = (bezier[0].X + bezier[3].X) * 0.5f;
var t1Y = (bezier[0].Y + bezier[3].Y) * 0.5f;
var t2 = Rotate(m, l1);
var t3 = Rotate(m, l2);
sink.BeginFigure(new RawVector2(t1X, t1Y), FigureBegin.Filled);
sink.AddLine(new RawVector2(t2.X + t1X, t2.Y + t1Y));
sink.AddLine(new RawVector2(t3.X + t1X, t3.Y + t1Y));
sink.EndFigure(FigureEnd.Closed);
}
public static List <ObjectPositionInfo> GeneratePositionInfos(IEnumerable <OsuHitObject> hitObjects)
{
var positionInfos = new List <ObjectPositionInfo>();
Vector2 previousPosition = playfield_centre;
float previousAngle = 0;
foreach (OsuHitObject hitObject in hitObjects)
{
Vector2 relativePosition = hitObject.Position - previousPosition;
float absoluteAngle = MathF.Atan2(relativePosition.Y, relativePosition.X);
float relativeAngle = absoluteAngle - previousAngle;
ObjectPositionInfo positionInfo;
positionInfos.Add(positionInfo = new ObjectPositionInfo(hitObject)
{
RelativeAngle = relativeAngle,
DistanceFromPrevious = relativePosition.Length
});
if (hitObject is Slider slider)
{
float absoluteRotation = getSliderRotation(slider);
positionInfo.Rotation = absoluteRotation - absoluteAngle;
absoluteAngle = absoluteRotation;
}
previousPosition = hitObject.EndPosition;
previousAngle = absoluteAngle;
}
return(positionInfos);
}
public static void Flock(Ship ship)
{
if (ship.World.Hook.FlockWeight == 0)
{
return;
}
var fleet = ship.Fleet;
var hook = ship.World.Hook;
if (fleet?.Ships == null || fleet.Ships.Count < 2)
{
return;
}
var shipFlockingVector =
(hook.FlockCohesion * Flocking.Cohesion(fleet.Ships, ship, hook.FlockCohesionMaximumDistance))
+ (hook.FlockSeparation * Flocking.Separation(fleet.Ships, ship, hook.FlockSeparationMinimumDistance));
var steeringVector = new Vector2(MathF.Cos(ship.Angle), MathF.Sin(ship.Angle));
steeringVector += hook.FlockWeight * shipFlockingVector;
ship.Angle = MathF.Atan2(steeringVector.Y, steeringVector.X);
}
