public void ShouldSetMagnitudeOfTargetVectorWithoutChangingActualVector()
{
PVector vectorA = new PVector(1, 2, 2);
float originalVectorAMagnitude = vectorA.Mag(); // Magnitude 3
PVector vectorACopy = vectorA.Copy();
PVector targetVector = new PVector(3, 4, 0);
float originalTargetVectorMagnitude = targetVector.Mag(); // Magnitude 5
float desiredNewMagnitude = 8f;
PVector resultVector = vectorA.SetMag(targetVector, desiredNewMagnitude);
float resultMagnitude = resultVector.Mag();
//Vector A should not change
Assert.Equal(originalVectorAMagnitude, vectorA.Mag());
Assert.Equal(vectorACopy.X, vectorA.X);
Assert.Equal(vectorACopy.Y, vectorA.Y);
Assert.Equal(vectorACopy.Z, vectorA.Z);
Assert.Same(targetVector, resultVector);
Assert.NotEqual(originalTargetVectorMagnitude, resultMagnitude);
Assert.Equal(desiredNewMagnitude, resultMagnitude);
}
public void ShouldNormalizeVector()
{
PVector aVector = new PVector(3, 4, 5);
float originalMagnitude = aVector.Mag();
PVector normalizedVector = aVector.Normalize();
Assert.Same(normalizedVector, aVector);
Assert.NotEqual(originalMagnitude, aVector.Mag());
Assert.Equal(1f, aVector.Mag());
}
public void ShouldReturnNormalizedVectorWithoutChangingActrualVector()
{
PVector vectorA = new PVector(3, 4, 5);
PVector vectorACopy = vectorA.Copy();
float originalMagnitude = vectorA.Mag();
PVector targetVector = new PVector(5, 5, 5);
PVector normalizedVector = vectorA.Normalize(targetVector);
//Vector A should not change
Assert.Equal(originalMagnitude, vectorA.Mag());
Assert.Equal(vectorACopy.X, vectorA.X);
Assert.Equal(vectorACopy.Y, vectorA.Y);
Assert.Equal(vectorACopy.Z, vectorA.Z);
Assert.Same(normalizedVector, targetVector);
Assert.NotEqual(1f, targetVector.Mag());
}
public void ShouldNotChangeMagnitudeIfActualMagnitudeIsLowerThanMaxValue()
{
PVector vectorA = new PVector(1, 2, 2); // Magnitude 3
float originalMagnitude = vectorA.Mag();
float maxMagnitude = 5f;
PVector limitedVector = vectorA.Limit(maxMagnitude);
float newMagnitude = limitedVector.Mag();
Assert.Same(vectorA, limitedVector);
Assert.Equal(3f, originalMagnitude);
Assert.Equal(originalMagnitude, newMagnitude);
}
public void ShouldCalculateMagnitudeOfVector()
{
PVector originalVector = new PVector(3, 4, 0);
float magnitude = originalVector.Mag();
Assert.Equal(5f, magnitude);
originalVector = new PVector(1, 2, 2);
magnitude = originalVector.Mag();
Assert.Equal(3, magnitude);
}
public void ShouldCreateUnitVectorFromGivenAngle()
{
float angle = (float)Math.PI / 2;
PVector vectorA = PVector.FromAngle(angle);
float calculatedAngle = vectorA.Heading();
float calculatedMagnitude = vectorA.Mag();
Assert.Equal(angle, calculatedAngle);
float diff = (float)Math.Abs(1f - calculatedMagnitude);
Assert.True(diff < ROUNDING_ERROR);
angle = (float)Math.PI / 4;
vectorA = PVector.FromAngle(angle);
calculatedAngle = vectorA.Heading();
calculatedMagnitude = vectorA.Mag();
Assert.Equal(angle, calculatedAngle);
diff = (float)Math.Abs(1f - calculatedMagnitude);
Assert.True(diff < ROUNDING_ERROR);
}
public void ShouldSetMagnitude()
{
PVector vectorA = new PVector(1, 2, 2); // Magnitude 3
float originalMagnitude = vectorA.Mag();
float desiredNewMagnitude = 5f;
PVector limitedVector = vectorA.SetMag(desiredNewMagnitude);
float newMagnitude = limitedVector.Mag();
Assert.Same(vectorA, limitedVector);
Assert.Equal(3f, originalMagnitude);
Assert.NotEqual(originalMagnitude, newMagnitude);
double roundingError = Math.Abs(desiredNewMagnitude - newMagnitude);
Assert.True(roundingError < ROUNDING_ERROR);
}
public void ShouldThowExceptionIfNewMagnitudeIsZeroOrLower()
{
PVector vectorA = new PVector(1, 2, 2); // Magnitude 3
float originalMagnitude = vectorA.Mag();
Assert.Throws <ArgumentException>(
"length",
() => { PVector limitedVector = vectorA.SetMag(-0.001f); }
);
Assert.Throws <ArgumentException>(
"length",
() => { PVector limitedVector = vectorA.SetMag(0f); }
);
}
