/// <summary>
/// Creates a new Arc
/// </summary>
/// <param name="radius">The radius of the arc</param>
/// <param name="bowLen">The lenght of the arc bow</param>
/// <param name="baseVector">The base vector of the arc start</param>
public Arc(double? radius, double? bowLen, Vector2 baseVector)
{
_angle = null;
_radius = radius;
_bowlen = bowLen;
_base = baseVector;
}
/// <summary>
/// Creates a new Arc
/// </summary>
/// <param name="radius">The radius of the arc</param>
/// <param name="bowLen">The lenght of the arc bow</param>
/// <param name="baseVector">The base vector of the arc start</param>
public Arc(double?radius, double?bowLen, Vector2 baseVector)
{
_angle = null;
_radius = radius;
_bowlen = bowLen;
_base = baseVector;
}
private static RenderOptions GeostationaryOptions(Angle?longitude = null, Angle?endLongitude = null)
{
return(new()
{
GeostationaryRender = new GeostationaryRenderOptions(longitude, endLongitude, false, 1.0f, 0.9f)
});
}
protected override void UpdateState(RadarConsoleComponent component)
{
var xform = Transform(component.Owner);
var onGrid = xform.ParentUid == xform.GridUid;
EntityCoordinates?coordinates = onGrid ? xform.Coordinates : null;
Angle? angle = onGrid ? xform.LocalRotation : null;
// Use ourself I guess.
if (TryComp <IntrinsicUIComponent>(component.Owner, out var intrinsic))
{
foreach (var uiKey in intrinsic.UIs)
{
if (uiKey.Key?.Equals(RadarConsoleUiKey.Key) == true)
{
coordinates = new EntityCoordinates(component.Owner, Vector2.Zero);
angle = Angle.Zero;
break;
}
}
}
var radarState = new RadarConsoleBoundInterfaceState(
component.MaxRange,
coordinates,
angle,
new List <DockingInterfaceState>());
_uiSystem.GetUiOrNull(component.Owner, RadarConsoleUiKey.Key)?.SetState(radarState);
}
/// <summary>
/// Creates a new Arc
/// </summary>
/// <param name="radius">The radius of the arc</param>
/// <param name="angle">The arc angle</param>
/// <param name="baseVector">A vector of the arc start</param>
public Arc(double? radius, Angle? angle, Vector2 baseVector)
{
_angle = angle;
_radius = radius;
_base = baseVector;
_bowlen = null;
}
/// <summary>
/// Creates a new Arc
/// </summary>
/// <param name="radius">The radius of the arc</param>
/// <param name="angle">The arc angle</param>
/// <param name="baseVector">A vector of the arc start</param>
public Arc(double?radius, Angle?angle, Vector2 baseVector)
{
_angle = angle;
_radius = radius;
_base = baseVector;
_bowlen = null;
}
/// <summary>
/// Constructs a new MDA sentence
/// </summary>
public WindDirectionWithRespectToNorth(Angle?trueWindDirection, Angle?magneticWindDirection, Speed?windSpeed)
: base(OwnTalkerId, Id, DateTimeOffset.UtcNow)
{
TrueWindDirection = trueWindDirection;
MagneticWindDirection = magneticWindDirection;
WindSpeed = windSpeed;
Valid = true;
}
/// <summary>
/// Constructs a new HDG sentence
/// </summary>
public HeadingAndDeclination(Angle headingTrue, Angle?deviation, Angle?variation)
: base(OwnTalkerId, Id, DateTimeOffset.UtcNow)
{
HeadingTrue = headingTrue;
Deviation = deviation;
Declination = variation;
Valid = true;
}
/// <summary>
/// Constructs a new VTG sentence
/// </summary>
public TrackMadeGood(Angle courseOverGroundTrue, Angle?courseOverGroundMagnetic, Speed speed)
: base(OwnTalkerId, Id, DateTimeOffset.UtcNow)
{
CourseOverGroundTrue = courseOverGroundTrue;
CourseOverGroundMagnetic = courseOverGroundMagnetic;
Speed = speed;
Valid = true;
}
public ShuttleConsoleBoundInterfaceState(
ShuttleMode mode,
float maxRange,
EntityCoordinates?coordinates,
Angle?angle,
List <DockingInterfaceState> docks) : base(maxRange, coordinates, angle, docks)
{
Mode = mode;
}
/// <summary>
/// Creates a regular polygon centered at the origin in the XY-plane.
/// </summary>
public static Polygon RegularPolygon(int numberOfSides, Distance sideLength, Angle?startingAngle = null, Point centerPoint = null)
{
if (numberOfSides < 3)
{
throw new ArgumentException("A polygon must have at least 3 sides.");
}
Angle step = (360.0 / numberOfSides) * Unit.Degrees;
Angle otherAngle = (Unit.StraightAngle - step) / 2;
//Law of Sines
Distance length = sideLength * Unit.Sine(otherAngle) / Unit.Sine(step);
Point firstPoint;
if (startingAngle == null)
{ // We want the polygon to be centered at the origin,
// and lie "flat" from the viewers perspective
if (numberOfSides % 4 == 0)
{
firstPoint = new Point(length, Unit.ZeroDistance);
firstPoint = firstPoint.Rotate2D(step / 2);
}
else if (numberOfSides % 2 == 0)
{
firstPoint = new Point(length, Unit.ZeroDistance);
}
else
{
firstPoint = new Point(Unit.ZeroDistance, length);
}
}
else
{
firstPoint = new Point(length, Unit.ZeroDistance);
firstPoint = firstPoint.Rotate2D(startingAngle.Value);
}
List <Point> points = new List <Point>()
{
firstPoint
};
for (int i = 1; i < numberOfSides; i++)
{
points.Add(firstPoint.Rotate2D(step * i));
}
if (centerPoint == null)
{
return(new Polygon(points, ValidateOption.Dont));
}
else
{
return(new Polygon(points.Select(p => centerPoint + p.VectorFromOrigin).ToList(), ValidateOption.Dont));
}
}
/// <summary>
/// Creates a new route point.
/// </summary>
/// <param name="routeName">Name of the route</param>
/// <param name="indexInRoute">The index of this point</param>
/// <param name="totalPointsInRoute">The total number of points on this route</param>
/// <param name="waypointName">The name of this waypoint</param>
/// <param name="position">The position of the waypoint</param>
/// <param name="bearingToNextWaypoint">The direction to the next waypoint (optional, will be calculated when the route is constructed)</param>
/// <param name="distanceToNextWaypoint">The distance to the next waypoint (optional, will be calculated when the route is constructed)</param>
/// <remarks>
/// Route and point names should use ASCII characters only. Some devices may understand the extended ASCII code page (values > 127),
/// but this is rare. Most devices will silently truncate any names longer than 10 chars.
/// </remarks>
public RoutePoint(string routeName, int indexInRoute, int totalPointsInRoute, string waypointName, GeographicPosition position,
Angle?bearingToNextWaypoint, Length?distanceToNextWaypoint)
{
RouteName = routeName;
IndexInRoute = indexInRoute;
TotalPointsInRoute = totalPointsInRoute;
WaypointName = waypointName;
Position = position;
BearingToNextWaypoint = bearingToNextWaypoint;
DistanceToNextWaypoint = distanceToNextWaypoint;
}
public RadarConsoleBoundInterfaceState(
float maxRange,
EntityCoordinates?coordinates,
Angle?angle,
List <DockingInterfaceState> docks)
{
MaxRange = maxRange;
Coordinates = coordinates;
Angle = angle;
Docks = docks;
}
public void NullAngle_ShouldReturnNull()
{
// arrange
Angle?angle = null;
// act
var result = -angle;
// assert
result.Should().BeNull();
}
public void DivideByNull_ShouldThrow()
{
// arrange
var angle = CreateAngleInUnitOtherThan(AngleUnit.Turn);
Angle?denominator = null;
// act
Func <number> divideByZero = () => angle / denominator;
// assert
divideByZero.Should().Throw <DivideByZeroException>();
}
private void Move(Angle direction1, float speed1, Angle?direction2, float?speed2)
{
Moving1.Direction = direction1;
Moving1.Speed = speed1;
if (direction2.HasValue)
{
Moving2.Direction = direction2.Value;
}
if (speed2.HasValue)
{
Moving2.Speed = speed2.Value;
}
Vector3 pos1 = Item1.Position;
Vector3 pos2 = (direction2 != null ? Item2.Position : Vector3.Zero);
Vector3 pos3 = Item3.Position;
bool second = direction2.HasValue;
Vector3 velocity = Vector3.Zero;
float strenght = 0;
velocity += Vector3.FromAngleXY(Moving1.Direction) * Math.Min(Moving1.Speed, Moving1.MaximumSpeed);
strenght += Carrier1.CarrierStrength;
velocity += Vector3.FromAngleXY(Moving3.Direction) * Math.Min(Moving3.Speed, Moving3.MaximumSpeed);
if (direction2 != null)
{
velocity += Vector3.FromAngleXY(Moving2.Direction) * Math.Min(Moving2.Speed, Moving2.MaximumSpeed);
strenght += Carrier2.CarrierStrength;
}
// Neue Positionen berechnen
float factor = Portable3.PortableWeight > 0 ? strenght / Portable3.PortableWeight : 1f;
factor = Math.Min(1f, Math.Max(0f, factor));
velocity = (velocity / (second ? 3 : 2)) * factor;
pos1 += velocity;
pos2 += velocity;
pos3 += velocity;
Engine.Update();
Assert.AreEqual(pos1.X, Item1.Position.X, 0.001f);
Assert.AreEqual(pos1.Y, Item1.Position.Y, 0.001f);
if (direction2 != null)
{
Assert.AreEqual(pos2.X, Item2.Position.X, 0.001f);
Assert.AreEqual(pos2.Y, Item2.Position.Y, 0.001f);
}
Assert.AreEqual(pos3.X, Item3.Position.X, 0.001f);
Assert.AreEqual(pos3.Y, Item3.Position.Y, 0.001f);
}
public void NullAngles_ShouldReturnNull()
{
// arrange
Angle?nullAngle1 = null;
Angle?nullAngle2 = null;
// act
var result = nullAngle1 - nullAngle2;
// assert
result.Should().BeNull();
}
public GeostationaryRenderOptions(
Angle?longitude,
Angle?endLongitude,
bool inverseRotation,
float hazeAmount,
float hazeOpacity)
{
InverseRotation = inverseRotation;
Longitude = longitude?.Radians;
EndLongitude = endLongitude?.Radians;
HazeAmount = hazeAmount;
HazeOpacity = hazeOpacity;
}
public void NullAngle_ShouldTreatNullAsDefault()
{
// arrange
Angle? nullAngle = null;
number factor = Fixture.Create <number>();
var expectedResult = default(Angle) * factor;
// act
var result = nullAngle * factor;
// assert
result.Should().NotBeNull();
result.Value.Should().Be(expectedResult);
}
public void NullAngle_ShouldTreatNullAsDefault()
{
// arrange
Angle? nullAngle = null;
number denominator = Fixture.CreateNonZeroNumber();
var expectedResult = default(Angle) % denominator;
// act
var result = nullAngle * denominator;
// assert
result.Should().NotBeNull();
result.Value.Should().Be(expectedResult);
}
/// <summary>
/// See <see cref="NmeaSentence"/> for constructor usage
/// </summary>
public RecommendedMinimumNavigationInformation(
DateTimeOffset dateTime,
NavigationStatus?status,
GeographicPosition position,
Speed speedOverGround,
Angle trackMadeGoodInDegreesTrue,
Angle?magneticVariationInDegrees)
: base(OwnTalkerId, Id, dateTime)
{
Status = status;
Position = position;
SpeedOverGround = speedOverGround;
TrackMadeGoodInDegreesTrue = trackMadeGoodInDegreesTrue;
MagneticVariationInDegrees = magneticVariationInDegrees;
Valid = true;
}
public void Prototype(IGeometry iprototype)
{
var prototype = (iprototype as Arc);
if (prototype == null)
{
throw new InvalidOperationException();
}
_angle = prototype.Angle;
_radius = prototype.Radius;
_bowlen = prototype.BowLen;
_base = prototype.BaseVector;
Location = prototype.Location;
Direction = prototype.Direction;
}
public Box2Rotated GetWorldBounds(TileRef tileRef, Matrix3?worldMatrix = null, Angle?angle = null)
{
var grid = _mapManager.GetGrid(tileRef.GridIndex);
if (worldMatrix == null || angle == null)
{
var gridXform = EntityManager.GetComponent <TransformComponent>(grid.GridEntityId);
var(_, wAng, wMat) = gridXform.GetWorldPositionRotationMatrix();
worldMatrix = wMat;
angle = wAng;
}
var center = worldMatrix.Value.Transform((Vector2)tileRef.GridIndices + 0.5f) * grid.TileSize;
var translatedBox = Box2.CenteredAround(center, (grid.TileSize, grid.TileSize));
return(new Box2Rotated(translatedBox, -angle.Value, center));
}
/// <summary>
/// Returns the range with the maximum value in a sequence of nullable Angle values.
/// </summary>
/// <param name="source">A sequence of Angle values to determine the maximum value of.</param>
/// <returns>The maximum value in the sequence.</returns>
/// <remarks>If the source sequence is empty or contains only values that are null, this function returns null.</remarks>
public static (Angle Min, Angle Max)? Range(this IEnumerable <Angle?> source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
using (var enumerator = source.GetEnumerator())
{
Angle?current = null;
do
{
if (!enumerator.MoveNext())
{
return(null); // sequence is empty
}
current = enumerator.Current;
}while (!current.HasValue);
var min = current.GetValueOrDefault();
var max = min;
while (enumerator.MoveNext())
{
current = enumerator.Current;
// Do not replace & with &&. The branch prediction cost outweighs the extra operation
// unless nulls either never happen or always happen.
if (current.HasValue)
{
var currentValue = current.GetValueOrDefault();
if (currentValue < min)
{
min = currentValue;
}
if (currentValue > max)
{
max = currentValue;
}
}
}
return(min, max);
}
}
public void NullAndAngle_ShouldTreatNullAsDefault()
{
// arrange
Angle?nullAngle = null;
var angle = CreateAngleInUnitOtherThan(AngleUnit.Turn);
// act
var result1 = angle - nullAngle;
var result2 = nullAngle - angle;
// assert
result1.Should().NotBeNull();
result1.Value.Turns.Should().Be(angle.Turns);
result1.Value.Unit.Should().Be(angle.Unit);
result2.Should().NotBeNull();
result2.Value.Turns.Should().Be(-angle.Turns);
result2.Value.Unit.Should().Be(angle.Unit);
}
public void MultipleSerialConversion_ShouldHaveSameValueAtTheEnd(number value)
{
// arrange
var units = new List <AngleUnit>
{
AngleUnit.Turn,
AngleUnit.Radian,
AngleUnit.Degree,
AngleUnit.Gradian,
AngleUnit.Turn
};
var initialAngle = new Angle(value, units.First());
Angle?finalAngle = null;
// act
units.ForEach(u => finalAngle = (finalAngle ?? initialAngle).Convert(u));
// assert
finalAngle.Should().Be(initialAngle);
}
public void Prototype(IGeometry iprototype)
{
var prototype = (iprototype as Arc);
if (prototype == null)
throw new InvalidOperationException();
_angle = prototype.Angle;
_radius = prototype.Radius;
_bowlen = prototype.BowLen;
_base = prototype.BaseVector;
Location = prototype.Location;
Direction = prototype.Direction;
}
/// <summary>
/// Creates a new Rectangle
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="rotation"></param>
public Rectangle2(double x, double y, double width, double height, Angle?rotation = null)
: this(BuildEdges(x, y, width, height, rotation))
{
}
/// <summary>
/// Builds the edges of a rectangle from a location and width/height.
/// Optionally, you can specify the rotation angle to the X-Axsis
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="rotation"></param>
/// <returns></returns>
public static Vector2[] BuildEdges(double x, double y, double width, double height, Angle?rotation = null)
{
var topLeft = new Vector2(x, y);
var topRight = new Vector2(x + width, y);
var bottomRight = new Vector2(x + width, y + height);
var bottomLeft = new Vector2(x, y + height);
var vertices = new Vertices(new[] { topLeft, topRight, bottomRight, bottomLeft });
// Rotate if necessary
if (rotation.HasValue && rotation.Value != Angle.Zero)
{
vertices = vertices.RotateVertices(topLeft, rotation.Value);
}
return(vertices.ToArray());
}
public Rectangle2(Vector2 location, SizeD size, Angle?rotation = null)
: this(location.X, location.Y, size.Width, size.Height, rotation ?? Angle.Zero)
{
}
public override void FrameUpdate(float frameTime)
{
if (!_gameTiming.IsFirstTimePredicted)
return;
var currentEye = _eyeManager.CurrentEye;
if (_playerManager.LocalPlayer?.ControlledEntity is not {} mob || Deleted(mob))
return;
// We can't lerp if the mob can't move!
if (!TryComp(mob, out IMoverComponent? mover))
return;
var moverLastGridAngle = mover.LastGridAngle;
// Let's not turn the camera into a washing machine when the game starts.
if (_lastGridAngle == null)
{
_lastGridAngle = moverLastGridAngle;
currentEye.Rotation = -moverLastGridAngle;
return;
}
// Check if the last lerp grid angle we have is not the same as the last mover grid angle...
if (!_lastGridAngle.Value.EqualsApprox(moverLastGridAngle))
{
// And now, we start lerping.
_lerpTo = moverLastGridAngle;
_lastGridAngle = moverLastGridAngle;
_lerpStartRotation = currentEye.Rotation;
_accumulator = 0f;
}
if (_lerpTo != null)
{
_accumulator += frameTime;
var lerpRot = -_lerpTo.Value.FlipPositive().Reduced();
var startRot = _lerpStartRotation.FlipPositive().Reduced();
var changeNeeded = Angle.ShortestDistance(startRot, lerpRot);
if (changeNeeded.EqualsApprox(Angle.Zero))
{
// Nothing to do here!
CleanupLerp();
return;
}
// Get how much the camera should have moved by now. Make it faster depending on the change needed.
var changeRot = (CameraRotateSpeed * Math.Max(1f, Math.Abs(changeNeeded) * 0.75f)) * _accumulator * Math.Sign(changeNeeded);
// How close is this from reaching the end?
var percentage = (float)Math.Abs(changeRot / changeNeeded);
currentEye.Rotation = Angle.Lerp(startRot, lerpRot, percentage);
// Either we have overshot, or we have taken way too long on this, emergency reset time
if (percentage >= 1.0f || _accumulator >= LerpTimeMax)
{
CleanupLerp();
}
void CleanupLerp()
{
currentEye.Rotation = -_lerpTo.Value;
_lerpStartRotation = currentEye.Rotation;
_lerpTo = null;
_accumulator = 0f;
}
}
else
{
// This makes it so rotating the camera manually is impossible...
// However, it is needed. Why? Because of a funny (hilarious, even) race condition involving
// ghosting, this system listening for attached mob changes, and the eye rotation being reset after our
// changes back to zero because of an EyeComponent state coming from the server being applied.
// At some point we'll need to come up with a solution for that. But for now, I just want to fix this.
currentEye.Rotation = -moverLastGridAngle;
}
}
public Rectangle2(AARectangle rect, Angle?rotation = null)
: this(rect.Location, rect.Size, rotation ?? Angle.Zero)
{
}
public Box2 GetWorldAABB(Vector2?worldPos = null, Angle?worldRot = null)
{
return(Icon.GetWorldAABB(worldPos));
}
