public SnowParticule(Vector2 position, float speed, float distanceMax, RadianAngle angle) : base(position, speed, distanceMax, angle)
{
Animation anim = new Animation(Bloodbender.ptr.Content.Load <Texture2D>("snow"), 16, 16);
anim.forceDepth(1);
addAnimation(anim);
}
public ParticuleTTL(Vector2 position, float speed, float lifeTime, RadianAngle angle) : base(position, speed)
{
this.lifeTime = lifeTime;
this.angle = angle;
referencePosition = position;
intermediatePosition = Vector2.Zero;
}
public SnowMarkParticule(Vector2 position, float speed, float distanceMax, RadianAngle angle) : base(position, speed, distanceMax, angle)
{
offSet = OffSet.BottomCenterHorizontal;
anim = new Animation(Bloodbender.ptr.Content.Load <Texture2D>("snowMark"));
addAnimation(anim);
anim.forceDepth(0);
}
public DestinationPointTestData(GeoCoordinate from, Length distance, RadianAngle bearing, GeoCoordinate expected)
{
From = from;
Distance = distance;
Bearing = bearing;
Expected = expected;
}
public ParticuleDTL(Vector2 position, float speed, float distanceMax, RadianAngle angle) : base(position, speed)
{
this.distanceMax = distanceMax;
this.angle = angle;
referencePosition = position;
intermediatePosition = Vector2.Zero;
}
public SnowSpawner(Vector2 position, RadianAngle angle, GraphicObj target, Vector2 offSetPosition) : base(position, angle, target, offSetPosition)
{
particuleFollowSpawner = true;
timeSpawn = 0.02f;
this.angle = 2.25f;
numberParticuleToPop = 5;
}
public BloodParticule(Vector2 position, float speed, float lifeTime, RadianAngle angle, float scaleIN) : base(position, speed, lifeTime, angle)
{
offSet = OffSet.BottomCenterHorizontal;
anim = new Animation(Bloodbender.ptr.Content.Load <Texture2D>("blood1hit"), 6, 0.06f, 32, 0, 0, 0);
anim.isLooping = false;
anim.reset();
addAnimation(anim);
scale = new Vector2(scaleIN, scaleIN);
}
public void ShouldProduceValidResultInSameUnit(RadianAngle originalRadianAngle, RadianAngle expectedRadianAngle)
{
// arrange
// act
var result = originalRadianAngle.ToNormalized();
// assert
result.Radians.Should().BeApproximately(expectedRadianAngle.Radians);
}
public ParticuleSpawner(Vector2 position, RadianAngle angle, GraphicObj target, Vector2 offSetPosition)
{
particules = new List <Particule>();
this.position = position;
this.target = target;
this.offSetPosition = offSetPosition;
this.angle = angle;
}
public GeoCoordinate(RadianAngle latitude, RadianAngle longitude)
{
Assert.IsInRange(latitude, -RadianAngle.Right, RadianAngle.Right, nameof(latitude));
Assert.IsInRange(longitude, -RadianAngle.Straight, RadianAngle.Straight, nameof(longitude));
_latitudeRadians = latitude;
_longitudeRadians = longitude;
_latitude = latitude.ToDegreeAngle();
_longitude = longitude.ToDegreeAngle();
}
public void Constructor_ShouldCreateValidRadianAngle()
{
// arrange
number radians = Fixture.Create <number>();
// act
var radianAngle = new RadianAngle(radians);
// assert
radianAngle.Radians.Should().Be(radians);
}
public void DefaultRadianAngle_ShouldBeEqualToZeroRadians()
{
// arrange
var defaultRadianAngle = default(RadianAngle);
var zeroRadiansRadianAngle = new RadianAngle(Constants.Zero);
// act
// assert
zeroRadiansRadianAngle.Equals(defaultRadianAngle).Should().BeTrue(because: "'new RadianAngle(Constants.Zero)' should be equal 'default(RadianAngle)'");
defaultRadianAngle.Equals(zeroRadiansRadianAngle).Should().BeTrue(because: "'default(RadianAngle)' should be equal 'new RadianAngle(Constants.Zero)'");
}
public void FromAngle_ShouldCreateValidRadianAngle()
{
// arrange
var angle = Fixture.Create <Angle>();
// act
var radianAngle = RadianAngle.FromAngle(angle);
// assert
radianAngle.Radians.Should().BeApproximately((number)angle.Convert(AngleUnit.Radian).Value);
}
public void RadianAngleCreateUsingParamlessConstructor_ShouldBeEqualToZeroRadians()
{
// arrange
var zeroRadiansRadianAngle = new RadianAngle(Constants.Zero);
var paramlessConstructedRadianAngle = new RadianAngle();
// act
// assert
zeroRadiansRadianAngle.Equals(paramlessConstructedRadianAngle).Should().BeTrue(because: "'new RadianAngle(Constants.Zero)' should be equal 'new RadianAngle()'");
paramlessConstructedRadianAngle.Equals(zeroRadiansRadianAngle).Should().BeTrue(because: "'new RadianAngle()' should be equal 'new RadianAngle(Constants.Zero)'");
}
public void ShouldProduceValidResult()
{
// arrange
var nominator = CreateRadianAngle();
var denominator = new RadianAngle(Fixture.CreateNonZeroNumber());
// act
number result = nominator / denominator;
// assert
result.Should().Be(nominator.Radians / denominator.Radians);
}
public void DivideByZero_ShouldThrow()
{
// arrange
var radianAngle = CreateRadianAngle();
var denominator = new RadianAngle(Constants.Zero);
// act
Func <number> divideByZero = () => radianAngle / denominator;
// assert
divideByZero.Should().Throw <DivideByZeroException>();
}
public void Serialize_ShouldReturnValidJson(number radians, string expectedJson)
{
// arrange
var angle = new RadianAngle(radians);
var converter = new GeoCoordinateJsonConverter();
// act
string actualJson = JsonConvert.SerializeObject(angle, converter);
// assert
actualJson.Should().Be(expectedJson);
}
public void ShouldReturnProperValue(GeoCoordinate from, Length distance, RadianAngle bearing, GeoCoordinate expected)
{
// arrange
number precision = (number)0.01m;
// act
var result = from.GetDestinationPoint(distance, bearing);
// assert
result.Latitude.TotalDegrees.Should().BeApproximately(expected.Latitude.TotalDegrees, precision);
result.Longitude.TotalDegrees.Should().BeApproximately(expected.Longitude.TotalDegrees, precision);
}
public void RadianAnglesOfDifferentUnitsEqualInRadians_ShouldBeEqual()
{
// arrange
var radianAngle1 = Fixture.Create <RadianAngle>();
var radianAngle2 = new RadianAngle(
radians: radianAngle1.Radians);
// act
bool equalsResult = radianAngle1.Equals(radianAngle2);
// assert
equalsResult.Should().BeTrue(because: $"{radianAngle1.Radians} rad == {radianAngle2.Radians} rad");
}
public void ShouldReturnValidResult()
{
// arrange
var source = Fixture.CreateMany <RadianAngle>(3).Select(e => new TestObject <RadianAngle>(e));
number expectedResultInMetres = Enumerable.Sum(source, e => e.Property.Radians);
var expectedResult = new RadianAngle(expectedResultInMetres);
// act
var result = AngularEnumerableExtensions.Sum(source, e => e.Property);
// assert
result.Radians.Should().Be(expectedResult.Radians);
}
public void ShouldReturnValidResult()
{
// arrange
var source = Fixture.CreateMany <RadianAngle>(3);
number expectedResultInRadians = Enumerable.Sum(source, e => e.Radians);
var expectedResult = new RadianAngle(expectedResultInRadians);
// act
var result = AngularEnumerableExtensions.Sum(source);
// assert
result.Radians.Should().Be(expectedResult.Radians);
}
public void ShouldCreateWithGivenValues(number latitudeRadians, number longitudeRadians)
{
// arrange
var latitude = new RadianAngle(latitudeRadians);
var longitude = new RadianAngle(longitudeRadians);
// act
var sut = new GeoCoordinate(latitude, longitude);
// assert
sut.LatitudeRadians.Should().Be(latitude);
sut.LongitudeRadians.Should().Be(longitude);
}
public void LongitudeOutOfRange_ShouldThrow(number longitudeRadians)
{
// arrange
var longitude = new RadianAngle(longitudeRadians);
// act
Action create = () => new GeoCoordinate(RadianAngle.Zero, longitude);
// assert
var exception = create.Should().Throw <ArgumentOutOfRangeException>().And;
exception.ParamName.Should().Be("longitude");
exception.ActualValue.Should().Be(longitude);
}
public void DefaultRadianAngleAndZeroWithOtherUnit_ShouldProduceZeroWithOtherUnit()
{
// arrange
var defaultRadianAngle = default(RadianAngle);
var zeroRadians = new RadianAngle(Constants.Zero);
// act
var result1 = defaultRadianAngle + zeroRadians;
var result2 = zeroRadians + defaultRadianAngle;
// assert
result1.IsZero().Should().BeTrue();
result2.IsZero().Should().BeTrue();
}
public override bool Update(float elapsed)
{
if (inWait == true)
{
return(false);
}
if (intermediatePosition.X >= distanceMax)
{
inWait = true;
}
position = intermediatePosition + referencePosition;
position = RadianAngle.rotate(referencePosition, position, angle);
return(true);
}
protected override void cookParticule()
{
particuleToCook.inWait = false;
particuleToCook.speed = Bloodbender.ptr.rdn.Next(100, 301);
particuleToCook.distanceMax = 1400;
particuleToCook.angle = angle + (Bloodbender.ptr.rdn.Next(-2000, 2001) / 10000.0f);
particuleToCook.position = position;
particuleToCook.position.X += Bloodbender.ptr.rdn.Next(-650, 651);
particuleToCook.position = RadianAngle.rotate(position, particuleToCook.position, (float)(angle + (Math.PI / 2)));
particuleToCook.referencePosition = particuleToCook.position;
particuleToCook.intermediatePosition = Vector2.Zero;
float s = (Bloodbender.ptr.rdn.Next(2000, 4001) / 10000.0f);
particuleToCook.scale = new Vector2(s, s);
}
public GeoCoordinate GetDestinationPoint(Length distance, RadianAngle bearing)
{
if (IsEmpty)
{
throw new ArgumentException("Cannot compute destination point from unknown coordinate.");
}
var φ1 = LatitudeRadians;
var λ1 = LongitudeRadians;
var δ = new RadianAngle(distance / EarthRadius);
var φ2 = MathA.Asin(MathA.Sin(φ1) * MathA.Cos(δ) + MathA.Cos(φ1) * MathA.Sin(δ) * MathA.Cos(bearing));
number y = MathA.Sin(bearing) * MathA.Sin(δ) * MathA.Cos(φ1);
number x = MathA.Cos(δ) - MathA.Sin(φ1) * MathA.Sin(φ2);
var Δλ = MathA.Atan2(y, x);
var λ2 = λ1 + Δλ;
// Normalize longitude to range -π ... +π (that is, -180° ... +180°)
λ2 = (λ2 + 3 * RadianAngle.PI) % (2 * Constants.PI) - RadianAngle.PI;
return(new GeoCoordinate(φ2, λ2));
}
public override bool Update(float elapsed)
{
currentAngleWithTarget = angleWith(target);
node.Update(elapsed);
node.body.Position = givePosition(0) * Bloodbender.pixelToMeter;
distanceAttackWithTarget = (float)distanceWith(target.position) + 10;
RadianAngle tmpangle = currentAngleWithTarget;
tmpangle -= (float)Math.PI / 2;
if (tmpangle < 0)
{
spriteEffect = SpriteEffects.None;
}
else if (tmpangle > 0)
{
spriteEffect = SpriteEffects.FlipHorizontally;
}
return(base.Update(elapsed));
}
public override bool Update(float elapsed)
{
if (inWait == true)
{
return(false);
}
if (timer >= lifeTime)
{
timer = 0;
inWait = true;
return(false);
}
else
{
timer += elapsed;
}
position = intermediatePosition + referencePosition;
position = RadianAngle.rotate(referencePosition, position, angle);
return(base.Update(elapsed));
}
public ParticuleSpawnerDTL(Vector2 position, RadianAngle angle, GraphicObj target, Vector2 offSetPosition) : base(position, angle, target, offSetPosition)
{
}
