public Settings()
{
this.allowedShapes = Shapes.All;
this.customSpeed = 0;
this.drawSpeed = Speed.Normal;
this.useTransparency = true;
}
public void TestConstructorValue()
{
Speed speed = new Speed("5 m/s");
Assert.AreEqual(5, speed.Value);
Assert.AreEqual(SpeedUnit.MetersPerSecond, speed.Units);
}
public Decoded(GeoPosition currentLocation, DateTime currentTime, Heading currentHeading, Speed currentSpeed)
{
CurrentLocation = currentLocation;
CurrentTime = currentTime;
CurrentHeading = currentHeading;
CurrentSpeed = currentSpeed;
}
public Fan(Cpu.PWMChannel pin)
{
this.pwmChannel = pin;
this.speed = Speed.None;
this.frequency = (double)100;
Start();
}
public void VerifyAllEnums()
{
var acceleration = new Acceleration(1, AccelerationUnit.BaseUnit);
var angle = new Angle(1, AngleUnit.BaseUnit);
var angularAcceleration = new AngularAcceleration(1, AngularAccelerationUnit.BaseUnit);
var area = new Area(1, AreaUnit.BaseUnit);
var density = new MassDensity(1, MassDensityUnit.BaseUnit);
var electricCurrent = new ElectricCurrent(1, ElectricCurrentUnit.BaseUnit);
var electricResistance = new ElectricResistance(1, ElectricResistanceUnit.BaseUnit);
var electricVoltage = new ElectricPotential(1, ElectricPotentialUnit.BaseUnit);
var energy = new Energy(1, EnergyUnit.BaseUnit);
var force = new Force(1, ForceUnit.BaseUnit);
var frequency = new Frequency(1, FrequencyUnit.BaseUnit);
var jerk = new Jerk(1, JerkUnit.BaseUnit);
var length = new Length(1, LengthUnit.BaseUnit);
var mass = new Mass(1, MassUnit.BaseUnit);
var massFlowRate = new MassFlowRate(1, MassFlowRateUnit.BaseUnit);
var momentum = new Momentum(1, MomentumUnit.BaseUnit);
var numeric = new Numeric(1, NumericUnit.BaseUnit);
var power = new Power(1, PowerUnit.BaseUnit);
var pressure = new Pressure(1, PressureUnit.BaseUnit);
var speed = new Speed(1, SpeedUnit.BaseUnit);
var temperature = new Temperature(1, TemperatureUnit.BaseUnit);
var time = new Time(1, TimeUnit.BaseUnit);
var torque = new Torque(1, TorqueUnit.BaseUnit);
var volume = new Volume(1, VolumeUnit.BaseUnit);
var volumetricFlowRate = new VolumetricFlowRate(1, VolumetricFlowRateUnit.BaseUnit);
}
public void TestConstructorValueCultureException()
{
Speed speed = new Speed("5", CultureInfo.CurrentCulture);
Assert.AreEqual(5, speed.Value);
Assert.AreEqual(SpeedUnit.MetersPerSecond, speed.Units);
}
public Hover(Speed p_xMove, Speed p_yMove, int p_duration, bool p_relativeToPlayer)
{
this.relativeToPlayer = p_relativeToPlayer;
this.duration = p_duration;
this.yMove = p_yMove;
this.xMove = p_xMove;
}
public void ConvertToSi(Speed v, string dimension)
{
if (dimension != "m/s" )
{
if (dimension == "km/h")
{
v.Value *= 0.277778;
}
if (dimension == "mph")
{
v.Value *= 0.44704;
}
if (dimension == "knot")
{
v.Value *= 0.514444;
}
if (dimension == "ft/s")
{
v.Value *= 0.3048;
}
else
{
throw new IncorrectDimensionOfSpeedException();
}
}
}
public Datum(DateTime time, Latitude latitude, Longitude longitude, Length altitude = null, Speed speed = null, Heading heading = null)
{
_time = time;
_location = new GeoPosition(latitude, longitude, altitude);
_speed = speed;
_heading = heading;
}
public Hover(Speed p_xMove, Speed p_yMove, int p_duration)
{
this.relativeToPlayer = false;
this.duration = p_duration;
this.yMove = p_yMove;
this.xMove = p_xMove;
}
public CollidingParticle(GameState game,
Position2 position, Velocity2 velocity,
Unit z, Speed vz,
bool collideWithProjectileColliders)
: base(game)
{
this.data = new Data(position, velocity, z, vz, collideWithProjectileColliders);
}
public Data(Position2 p, Velocity2 v, Unit z, Speed vz, bool collideWithProjectileColliders)
{
this.position = p;
this.velocity = v;
this.z = z;
this.vz = vz;
this.collideWithProjectileColliders = collideWithProjectileColliders;
}
public MeterAtSecond ConvertToMeterAtSecond(Speed speed)
{
if(speed is MeterAtSecond)
{
return new MeterAtSecond(speed.value);
}
return new MeterAtSecond((speed.value * 1000) / 3600);
}
public void OpAddition()
{
var speed1 = new Speed(3600, SpeedUnit.MetersPerHour);
var speed2 = new Speed(1, SpeedUnit.MetersPerMinute);
var expected = new Speed(3660, SpeedUnit.MetersPerHour);
(speed1 + speed2).ShouldEqual(expected);
(speed2 + speed1).ShouldEqual(expected);
}
// Use this for initialization
void Start()
{
speedEnum = Speed.faster;
startSpeed = speed;
startVector = transform.position;
player = GameObject.FindGameObjectWithTag("Player").GetComponent<Player>();
moveCamera = GameObject.FindGameObjectWithTag("MainCamera").GetComponent<MoveCamera>();
}
/// <summary>
/// Initializes a new instance of the <see cref="ShipMoveOrder" /> class.
/// </summary>
/// <param name="source">The source of the order.</param>
/// <param name="target">The move target.</param>
/// <param name="speed">The move speed.</param>
/// <param name="isFleetwide">if set to <c>true</c> the move should be coordinated as a fleet.</param>
/// <param name="targetStandoffDistance">When the ship arrives at the target, this is the distance
/// from the target it should strive to achieve.</param>
public ShipMoveOrder(OrderSource source, IShipNavigable target, Speed speed, bool isFleetwide, float targetStandoffDistance)
: base(ShipDirective.Move, source, false, target) {
Utility.ValidateNotNull(target);
D.AssertNotDefault((int)speed);
Utility.ValidateNotNegative(targetStandoffDistance);
Speed = speed;
IsFleetwide = isFleetwide;
TargetStandoffDistance = targetStandoffDistance;
}
public void OpInverseEquals()
{
var speed1 = new Speed(3600, SpeedUnit.MetersPerHour);
var speed2 = new Speed(60, SpeedUnit.MetersPerMinute);
var speed3 = new Speed(120, SpeedUnit.MetersPerMinute);
(speed1 != speed2).ShouldBeFalse();
(speed2 != speed1).ShouldBeFalse();
(speed1 != speed3).ShouldBeTrue();
(speed3 != speed1).ShouldBeTrue();
}
public void OpDivision()
{
var speed1 = new Speed(3600, SpeedUnit.MetersPerHour);
var speed2 = new Speed(60, SpeedUnit.MetersPerMinute);
(speed1 / speed2).ShouldBeWithinEpsilonOf(1);
(speed2 / speed1).ShouldBeWithinEpsilonOf(1);
(speed1 / 2).ShouldEqual(new Speed(1800, SpeedUnit.MetersPerHour));
(speed2 / 2).ShouldEqual(new Speed(30, SpeedUnit.MetersPerMinute));
}
public void OpGreaterThanOrEqual()
{
var speed1 = new Speed(3600, SpeedUnit.MetersPerHour);
var speed2 = new Speed(60, SpeedUnit.MetersPerMinute);
var speed3 = new Speed(120, SpeedUnit.MetersPerMinute);
(speed1 >= speed3).ShouldBeFalse();
(speed3 >= speed1).ShouldBeTrue();
(speed1 >= speed2).ShouldBeTrue();
(speed2 >= speed1).ShouldBeTrue();
}
static void Main(string[] args)
{
Time t = new Time(5);
Speed v = new Speed(10);
Distance s = new Distance(10);
Acceleration a = new Acceleration(3);
s = 2 + (a * (t^2)) / 2;
Converter conv = new Converter();
Console.WriteLine(a.GiveValueInSI());
Console.ReadLine();
}
public static void EnableSpaceNavigator(this SceneView sceneView, Speed move = Speed.Normal, Speed zoom = Speed.Normal, Speed rotation = Speed.Normal, Speed tilt = Speed.Normal)
{
if (_device == null)
{
_device = new Device();
_device.Connect();
}
var sensor = _device.Sensor;
sensor.SensorInput += () => sceneView.Update(sensor, move.Translate(4000000), zoom.Translate(4000000), rotation.Translate(50000), tilt.Translate(40));
}
public Jump(Speed p_xspeed, Speed p_yspeed, bool playJumpAnim, bool dequeueOnLand)
{
this.horizontal = true;
this.vertical = true;
this.dqOnLand = true;
this.horizontal = true;
this.vertical = true;
this.dqOnLand = dequeueOnLand;
this.playAnim = playJumpAnim;
this.xSpeed = p_xspeed;
this.ySpeed = p_yspeed;
}
public SpeedRangeTarget(double minUnitsPerHour, double maxUnitsPerHour, Length.Units speedUnit, Speed.Units speedPace, BaseSpeedTarget baseTarget)
: this(baseTarget)
{
if (speedPace == Speed.Units.Pace)
{
SetRangeInMinutesPerUnit(minUnitsPerHour, maxUnitsPerHour, speedUnit);
}
else
{
SetRangeInUnitsPerHour(minUnitsPerHour, maxUnitsPerHour, speedUnit);
}
}
public void Update()
{
if (Input.GetKeyDown(KeyCode.P))
currentSpeed = Speed.Paused;
if (Input.GetKeyDown(KeyCode.Alpha1))
currentSpeed = Speed.Normal;
if (Input.GetKeyDown(KeyCode.Alpha2))
currentSpeed = Speed.Fast;
if (Input.GetKeyDown(KeyCode.Alpha3))
currentSpeed = Speed.Super;
}
public Weapon CreateWeapon(int minRange, int range, int damage, string name, AttributeEnum attribute, int cost, bool availlable, Speed speed, ISession session)
{
var weapon = new Weapon();
weapon.Damage = damage;
weapon.MinRange = minRange;
weapon.MaxRange = range;
weapon.Name = name;
weapon.ScalingAttribute = attribute;
weapon.Cost = cost;
weapon.Available = availlable;
weapon.Speed = speed;
session.Save(weapon);
return weapon;
}
private static void Main(string[] args)
{
var vehicleMass = new Mass(2500, MassUnit.Pounds);
var startSpeed = new Speed(72, SpeedUnit.MilesPerHour);
var endSpeed = new Speed(0, SpeedUnit.MilesPerHour);
var stoppingDistance = new Length(1234, LengthUnit.Foot);
Acceleration deceleration = ((endSpeed * endSpeed) - (startSpeed * startSpeed)) / (2 * stoppingDistance);
Force stoppingForceRequired = vehicleMass * deceleration;
Console.WriteLine("The stopping force required is:");
Console.WriteLine("\t{0}", stoppingForceRequired.ToString(ForceUnit.Newtons, 3));
Console.WriteLine("\t{0}", stoppingForceRequired.ToString(ForceUnit.KilogramForce, 3));
Console.WriteLine("\t{0}", stoppingForceRequired.ToString(ForceUnit.PoundForce, 3));
Console.ReadLine();
}
public override void Execute(Speed speed)
{
SlowDownAndPaint(speed);
Script.Player.Mouse.UseOn(Control);
if(Args == "Click")
{
Script.Player.Mouse.Click();
}
SlowDownAndPaint(speed);
Script.Player.Mouse.Dispose();
}
public override void Execute(Speed speed)
{
SlowDownAndPaint(speed);
Script.Player.Keyboard.UseOn(Control);
string TypeCommand = "Type ";
if(Args.StartsWith(TypeCommand))
{
Script.Player.Keyboard.Type(Args.Substring(TypeCommand.Length));
}
SlowDownAndPaint(speed);
Script.Player.Keyboard.Dispose();
}
public void OpEquals()
{
var speed1 = new Speed(3600, SpeedUnit.MetersPerHour);
var speed2 = new Speed(60, SpeedUnit.MetersPerMinute);
var speed3 = new Speed(120, SpeedUnit.MetersPerMinute);
(speed1 == speed2).ShouldBeTrue();
(speed2 == speed1).ShouldBeTrue();
(speed1 == speed3).ShouldBeFalse();
(speed3 == speed1).ShouldBeFalse();
speed1.Equals(speed2)
.ShouldBeTrue();
speed1.Equals((object)speed2)
.ShouldBeTrue();
speed2.Equals(speed1)
.ShouldBeTrue();
speed2.Equals((object)speed1)
.ShouldBeTrue();
}
public Jump(Speed p_speed, bool p_horizontal, bool playJumpAnim, bool dequeueOnLand)
{
this.horizontal = true;
this.vertical = true;
this.dqOnLand = true;
this.dqOnLand = dequeueOnLand;
this.playAnim = playJumpAnim;
if (p_horizontal)
{
this.vertical = false;
this.horizontal = true;
this.xSpeed = p_speed;
}
else
{
this.vertical = true;
this.horizontal = false;
this.ySpeed = p_speed;
}
}
public void MassFluxDividedByDensityEqualsSpeed()
{
Speed speed = MassFlux.FromKilogramsPerSecondPerSquareMeter(20) / Density.FromKilogramsPerCubicMeter(2);
Assert.Equal(speed, Speed.FromMetersPerSecond(10));
}
public static void KinematicViscosityDividedByLengthEqualsSpeed()
{
Speed speed = KinematicViscosity.FromSquareMetersPerSecond(4) / Length.FromMeters(2);
Assert.AreEqual(speed, Speed.FromMetersPerSecond(2));
}
internal static double CalculateTime(Speed initialSpeed, Speed desiredSpeed, Acceleration acceleration, int stepCountLimit, out Speed reachedSpeed, out int stepCount)
{
if (stepCountLimit == 0)
{
reachedSpeed = Speed.Zero;
stepCount = 0;
return(0);
}
checked
{
var absStepCountLimit = Math.Abs(stepCountLimit);
//TODO verify/improve precision
var timeScale = Configuration.TimerFrequency;
var initialSpeedF = initialSpeed.Ticks == 0 ? 0.0 : 1.0 * initialSpeed.StepCount / initialSpeed.Ticks * timeScale;
var desiredSpeedF = desiredSpeed.Ticks == 0 ? 0.0 : 1.0 * desiredSpeed.StepCount / desiredSpeed.Ticks * timeScale;
var accelerationF = 1.0 * acceleration.Speed.StepCount / acceleration.Speed.Ticks / acceleration.Ticks * timeScale * timeScale;
var desiredAccelerationTime = Math.Abs(desiredSpeedF - initialSpeedF) / accelerationF;
var isDeceleration = initialSpeedF > desiredSpeedF;
var decelerationCoefficient = isDeceleration ? -1 : 1;
var a = 0.5 * accelerationF;
var b = initialSpeedF * decelerationCoefficient;
var c = -absStepCountLimit;
var availableAccelerationTime = (-b + Math.Sqrt(b * b - 4 * a * c)) / 2 / a;
var accelerationTime = Math.Min(desiredAccelerationTime, availableAccelerationTime);
var accelerationDistanceF = (initialSpeedF * accelerationTime + 0.5 * decelerationCoefficient * accelerationF * accelerationTime * accelerationTime);
stepCount = (int)accelerationDistanceF * Math.Sign(stepCountLimit);
var reachedSpeedF = initialSpeedF + decelerationCoefficient * accelerationF * accelerationTime;
reachedSpeed = new Speed((int)reachedSpeedF, timeScale);
return(accelerationTime);
}
}
public SpeedHandler(Speed speed)
{
speedAdjust = setSpeedAdjust(speed);
}
public Speed(Speed obj) : base(obj)
{
}
public override string ExecuteReadOption(string Option)
{
switch (Option)
{
case ("MoveTo"):
throw new InvalidOperationException("Executeable");
case ("MoveRelativeTo"):
throw new InvalidOperationException("Executeable");
case ("MoveFor"):
throw new InvalidOperationException("Executeable");
case ("RunOn"):
throw new InvalidOperationException("Executeable");
case ("RunAt"):
throw new InvalidOperationException("Executeable");
case ("Stop"):
throw new InvalidOperationException("Executeable");
case ("Reset"):
throw new InvalidOperationException("Executeable");
case ("Address"):
return(Address);
case ("MaxSpeed"):
return(Max_Speed.ToString());
case ("Speed"):
return(Speed.ToString());
case ("Position"):
return(Position.ToString());
case ("Dutycycle"):
return(Dutycycle.ToString());
case ("RampUpSpeed"):
return(RampUpSpeed.ToString());
case ("RampDownSpeed"):
return(RampDownSpeed.ToString());
case ("Polarity"):
return(TachoMotor_Polarity_To_String(Polarity));
case ("RPM"):
return(RPM.ToString());
case ("DriverName"):
return(DriverName);
case ("LastCommand"):
return(TachoMotor_Commands_To_String(LastCommand));
case ("State"):
return(TachoMotor_States_To_String(State));
case ("StopAction"):
return(TachoMotor_StopActions_To_String(StopAction));
case ("Command"):
throw new InvalidOperationException("WriteOnly");
default:
throw new ArgumentOutOfRangeException();
}
}
public void AreaTimesSpeedEqualsVolumeFlow()
{
VolumeFlow volumeFlow = Area.FromSquareMeters(20) * Speed.FromMetersPerSecond(2);
Assert.Equal(VolumeFlow.FromCubicMetersPerSecond(40), volumeFlow);
}
/// <summary>
/// Adds ramped line with specified number of steps.
/// </summary>
/// <param name="xSteps">Number of steps along x.</param>
/// <param name="ySteps">Numer of steps along y.</param>
/// <param name="planeAcceleration">Acceleration used for ramping - calculated for both axis combined.</param>
/// <param name="planeSpeedLimit">Maximal speed that could be achieved for both axis combined.</param>
public void AddRampedLineXY(int xSteps, int ySteps, Acceleration planeAcceleration, Speed planeSpeedLimit)
{
if (xSteps == 0 && ySteps == 0)
{
//nothing to do
return;
}
Speed speedLimitX, speedLimitY;
DecomposeXY(xSteps, ySteps, planeSpeedLimit, out speedLimitX, out speedLimitY);
Acceleration accelerationX, accelerationY;
DecomposeXY(xSteps, ySteps, planeAcceleration, out accelerationX, out accelerationY);
Speed reachedX, reachedY;
int accelerationStepsX, accelerationStepsY;
var timeX = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitX, accelerationX, xSteps / 2, out reachedX, out accelerationStepsX);
var timeY = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitY, accelerationY, ySteps / 2, out reachedY, out accelerationStepsY);
//take acceleration time according to axis with more precision
var accelerationTime = Math.Max(timeX, timeY);
var accelerationProfileX = AccelerationBuilder.FromTo(Speed.Zero, reachedX, accelerationStepsX, accelerationTime);
var accelerationProfileY = AccelerationBuilder.FromTo(Speed.Zero, reachedY, accelerationStepsY, accelerationTime);
var reachedSpeedX = Speed.FromDeltaT(accelerationProfileX.EndDelta + accelerationProfileX.BaseDeltaT);
var reachedSpeedY = Speed.FromDeltaT(accelerationProfileY.EndDelta + accelerationProfileY.BaseDeltaT);
var reachedSpeed = ComposeSpeeds(reachedSpeedX, reachedSpeedY);
var decelerationProfileX = AccelerationBuilder.FromTo(reachedX, Speed.Zero, accelerationStepsX, accelerationTime);
var decelerationProfileY = AccelerationBuilder.FromTo(reachedY, Speed.Zero, accelerationStepsY, accelerationTime);
var remainingX = xSteps - accelerationProfileX.StepCount - decelerationProfileX.StepCount;
var remainingY = ySteps - accelerationProfileY.StepCount - decelerationProfileY.StepCount;
//send ramp
AddAccelerationXY(accelerationProfileX, accelerationProfileY);
AddConstantSpeedTransitionXY(remainingX, remainingY, reachedSpeed);
AddAccelerationXY(decelerationProfileX, decelerationProfileY);
}
/// <summary>
/// Adds 4D transition with constant speed.
/// </summary>
/// <param name="distanceU">Distance along U axis in steps.</param>
/// <param name="distanceV">Distance along V axis in steps.</param>
/// <param name="transitionSpeedUV">Speed of the transition in uv plane.</param>
/// <param name="distanceX">Distance along X axis in steps.</param>
/// <param name="distanceY">Distance along Y axis in steps.</param>
/// <param name="transitionSpeedXY">Speed of the transition in xy plane.</param>
public void AddConstantSpeedTransitionUVXY(int distanceU, int distanceV, Speed transitionSpeedUV, int distanceX, int distanceY, Speed transitionSpeedXY)
{
checked
{
var sqrtUV = Math.Sqrt(1.0 * distanceU * distanceU + 1.0 * distanceV * distanceV);
var sqrtXY = Math.Sqrt(1.0 * distanceX * distanceX + 1.0 * distanceY * distanceY);
var transitionTimeUV = sqrtUV == 0 ? 0 : (long)(sqrtUV * transitionSpeedUV.Ticks / transitionSpeedUV.StepCount);
var transitionTimeXY = sqrtXY == 0 ? 0 : (long)(sqrtXY * transitionSpeedXY.Ticks / transitionSpeedXY.StepCount);
var transitionTime = Math.Max(transitionTimeUV, transitionTimeXY);
var remainingStepsU = distanceU;
var remainingStepsV = distanceV;
var remainingStepsX = distanceX;
var remainingStepsY = distanceY;
var chunkLengthLimit = Constants.MaxStepInstructionLimit;
var maxUV = Math.Max(Math.Abs(distanceU), Math.Abs(distanceV));
var maxXY = Math.Max(Math.Abs(distanceX), Math.Abs(distanceY));
var chunkCount = (int)Math.Ceiling(1.0 * Math.Max(maxUV, maxXY) / chunkLengthLimit);
var doneDistanceU = 0L;
var doneDistanceV = 0L;
var doneDistanceX = 0L;
var doneDistanceY = 0L;
var doneTime = 0.0;
for (var doneChunks = 1; doneChunks <= chunkCount; ++doneChunks)
{
var chunkDistanceU = 1.0 * distanceU * doneChunks / chunkCount;
var chunkDistanceV = 1.0 * distanceV * doneChunks / chunkCount;
var chunkDistanceX = 1.0 * distanceX * doneChunks / chunkCount;
var chunkDistanceY = 1.0 * distanceY * doneChunks / chunkCount;
var chunkTime = 1.0 * transitionTime * doneChunks / chunkCount;
var stepCountUD = chunkDistanceU - doneDistanceU;
var stepCountVD = chunkDistanceV - doneDistanceV;
var stepCountXD = chunkDistanceX - doneDistanceX;
var stepCountYD = chunkDistanceY - doneDistanceY;
var stepsTime = chunkTime - doneTime;
var stepCountU = (Int16)Math.Round(stepCountUD);
var stepCountV = (Int16)Math.Round(stepCountVD);
var stepCountX = (Int16)Math.Round(stepCountXD);
var stepCountY = (Int16)Math.Round(stepCountYD);
doneDistanceU += stepCountU;
doneDistanceV += stepCountV;
doneDistanceX += stepCountX;
doneDistanceY += stepCountY;
//we DON'T want to round here - this way we can distribute time precisely via time remainders
var stepTimeU = stepCountU == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountU));
var stepTimeV = stepCountV == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountV));
var stepTimeX = stepCountX == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountX));
var stepTimeY = stepCountY == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountY));
var timeRemainderU = Math.Abs(stepCountUD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountUD));
var timeRemainderV = Math.Abs(stepCountVD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountVD));
var timeRemainderX = Math.Abs(stepCountXD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountXD));
var timeRemainderY = Math.Abs(stepCountYD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountYD));
if (stepTimeU == 0 && stepTimeV == 0 && stepTimeX == 0 && stepTimeY == 0)
{
if (doneDistanceU == distanceU && doneDistanceV == distanceV && doneDistanceX == distanceX && doneDistanceY == distanceY)
{
break;
}
throw new NotImplementedException("Send wait signal");
}
doneTime += stepsTime;
var uPart = createConstant(stepCountU, stepTimeU, timeRemainderU);
var vPart = createConstant(stepCountV, stepTimeV, timeRemainderV);
var xPart = createConstant(stepCountX, stepTimeX, timeRemainderX);
var yPart = createConstant(stepCountY, stepTimeY, timeRemainderY);
AddUVXY(uPart, vPart, xPart, yPart);
}
if (
distanceU != doneDistanceU ||
distanceV != doneDistanceV ||
distanceX != doneDistanceX ||
distanceY != doneDistanceY
)
{
throw new NotImplementedException("Distance was not calculated precisely. Needs to be fixed.");
}
}
}
/// <summary>
/// Adds line with specified initial and desired speed.
/// </summary>
/// <param name="xSteps">Number of steps along x.</param>
/// <param name="ySteps">Numer of steps along y.</param>
/// <param name="planeAcceleration">Acceleration used for getting desired speed out of initial.</param>
public Speed AddLineXY(int xSteps, int ySteps, Speed initialSpeed, Acceleration planeAcceleration, Speed desiredEndSpeed)
{
if (xSteps == 0 && ySteps == 0)
{
//nothing to do
return(initialSpeed);
}
Speed speedLimitX, speedLimitY;
DecomposeXY(xSteps, ySteps, desiredEndSpeed, out speedLimitX, out speedLimitY);
Speed initialSpeedX, initialSpeedY;
DecomposeXY(xSteps, ySteps, initialSpeed, out initialSpeedX, out initialSpeedY);
Acceleration accelerationX, accelerationY;
DecomposeXY(xSteps, ySteps, planeAcceleration, out accelerationX, out accelerationY);
Speed reachedX, reachedY;
int accelerationStepsX, accelerationStepsY;
var timeX = AccelerationBuilder.CalculateTime(initialSpeedX, speedLimitX, accelerationX, xSteps, out reachedX, out accelerationStepsX);
var timeY = AccelerationBuilder.CalculateTime(initialSpeedY, speedLimitY, accelerationY, ySteps, out reachedY, out accelerationStepsY);
//take acceleration time according to axis with more precision
var accelerationTime = Math.Max(timeX, timeY);
var accelerationProfileX = AccelerationBuilder.FromTo(initialSpeedX, reachedX, accelerationStepsX, accelerationTime);
var accelerationProfileY = AccelerationBuilder.FromTo(initialSpeedY, reachedY, accelerationStepsY, accelerationTime);
var reachedSpeedX = Speed.FromDeltaT(accelerationProfileX.EndDelta + accelerationProfileX.BaseDeltaT);
var reachedSpeedY = Speed.FromDeltaT(accelerationProfileY.EndDelta + accelerationProfileY.BaseDeltaT);
var reachedSpeed = ComposeSpeeds(reachedSpeedX, reachedSpeedY);
var remainingX = xSteps - accelerationProfileX.StepCount;
var remainingY = ySteps - accelerationProfileY.StepCount;
if (accelerationProfileX.StepCount == 0 && accelerationProfileY.StepCount == 0)
{
reachedSpeed = initialSpeed;
}
//send profile
AddAccelerationXY(accelerationProfileX, accelerationProfileY);
AddConstantSpeedTransitionXY(remainingX, remainingY, reachedSpeed);
return(reachedSpeed);
}
/// <summary>
/// Adds ramped line with specified number of steps.
/// </summary>
/// <param name="uSteps">Number of steps along u.</param>
/// <param name="vSteps">Numer of steps along v.</param>
/// <param name="xSteps">Number of steps along x.</param>
/// <param name="ySteps">Numer of steps along y.</param>
/// <param name="planeAcceleration">Acceleration used for ramping - calculated for both axis combined.</param>
/// <param name="planeSpeedLimit">Maximal speed that could be achieved for both axis combined.</param>
public void AddRampedLineUVXY(int uSteps, int vSteps, int xSteps, int ySteps, Acceleration planeAcceleration, Speed planeSpeedLimit)
{
if (uSteps == 0 && vSteps == 0 && xSteps == 0 && ySteps == 0)
{
//nothing to do
return;
}
Speed speedLimitU, speedLimitV;
DecomposeXY(uSteps, vSteps, planeSpeedLimit, out speedLimitU, out speedLimitV);
Acceleration accelerationU, accelerationV;
DecomposeXY(uSteps, vSteps, planeAcceleration, out accelerationU, out accelerationV);
Speed speedLimitX, speedLimitY;
DecomposeXY(xSteps, ySteps, planeSpeedLimit, out speedLimitX, out speedLimitY);
Acceleration accelerationX, accelerationY;
DecomposeXY(xSteps, ySteps, planeAcceleration, out accelerationX, out accelerationY);
Speed reachedU, reachedV, reachedX, reachedY;
int accelerationStepsU, accelerationStepsV, accelerationStepsX, accelerationStepsY;
var timeU = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitU, accelerationU, uSteps / 2, out reachedU, out accelerationStepsU);
var timeV = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitV, accelerationV, vSteps / 2, out reachedV, out accelerationStepsV);
var timeX = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitX, accelerationX, xSteps / 2, out reachedX, out accelerationStepsX);
var timeY = AccelerationBuilder.CalculateTime(Speed.Zero, speedLimitY, accelerationY, ySteps / 2, out reachedY, out accelerationStepsY);
//take acceleration time according to axis with more precision
var accelerationTime = Math.Max(Math.Max(timeU, timeV), Math.Max(timeX, timeY));
var accelerationProfileU = AccelerationBuilder.FromTo(Speed.Zero, reachedU, accelerationStepsU, accelerationTime);
var accelerationProfileV = AccelerationBuilder.FromTo(Speed.Zero, reachedV, accelerationStepsV, accelerationTime);
var accelerationProfileX = AccelerationBuilder.FromTo(Speed.Zero, reachedX, accelerationStepsX, accelerationTime);
var accelerationProfileY = AccelerationBuilder.FromTo(Speed.Zero, reachedY, accelerationStepsY, accelerationTime);
var reachedSpeedU = Speed.FromDeltaT(accelerationProfileU.EndDelta + accelerationProfileU.BaseDeltaT);
var reachedSpeedV = Speed.FromDeltaT(accelerationProfileV.EndDelta + accelerationProfileV.BaseDeltaT);
var reachedSpeedX = Speed.FromDeltaT(accelerationProfileX.EndDelta + accelerationProfileX.BaseDeltaT);
var reachedSpeedY = Speed.FromDeltaT(accelerationProfileY.EndDelta + accelerationProfileY.BaseDeltaT);
var reachedSpeedUV = ComposeSpeeds(reachedSpeedU, reachedSpeedV);
var reachedSpeedXY = ComposeSpeeds(reachedSpeedX, reachedSpeedY);
var decelerationProfileU = AccelerationBuilder.FromTo(reachedU, Speed.Zero, accelerationStepsU, accelerationTime);
var decelerationProfileV = AccelerationBuilder.FromTo(reachedV, Speed.Zero, accelerationStepsV, accelerationTime);
var decelerationProfileX = AccelerationBuilder.FromTo(reachedX, Speed.Zero, accelerationStepsX, accelerationTime);
var decelerationProfileY = AccelerationBuilder.FromTo(reachedY, Speed.Zero, accelerationStepsY, accelerationTime);
var remainingU = uSteps - accelerationProfileU.StepCount - decelerationProfileU.StepCount;
var remainingV = vSteps - accelerationProfileV.StepCount - decelerationProfileV.StepCount;
var remainingX = xSteps - accelerationProfileX.StepCount - decelerationProfileX.StepCount;
var remainingY = ySteps - accelerationProfileY.StepCount - decelerationProfileY.StepCount;
//send ramp
AddAccelerationUVXY(accelerationProfileU, accelerationProfileV, accelerationProfileX, accelerationProfileY);
AddConstantSpeedTransitionUVXY(remainingU, remainingV, reachedSpeedUV, remainingX, remainingY, reachedSpeedXY);
AddAccelerationUVXY(decelerationProfileU, decelerationProfileV, decelerationProfileX, decelerationProfileY);
}
/// <summary>
/// Decomposes plane speed into separate axes speeds in a direction specified by step counts.
/// </summary>
/// <param name="planeSpeed">Speed within the plane</param>
/// <param name="speedX">Output speed for x axis.</param>
/// <param name="speedY">Output speed for y axis.</param>
public void DecomposeXY(int stepsX, int stepsY, Speed planeSpeed, out Speed speedX, out Speed speedY)
{
//TODO verify/improve precision
checked
{
if (stepsX == 0 && stepsY == 0)
{
speedX = Speed.Zero;
speedY = Speed.Zero;
return;
}
var direction = new Vector(stepsX, stepsY);
direction.Normalize();
var speedVector = direction * planeSpeed.StepCount / planeSpeed.Ticks;
var resolution = Constants.TimerFrequency;
speedX = new Speed((long)Math.Round(Math.Abs(speedVector.X * resolution)), resolution);
speedY = new Speed((long)Math.Round(Math.Abs(speedVector.Y * resolution)), resolution);
}
}
} // time zulu
private void addToRoute(GeoCoord location, Waypoint wpt, Earthquake eq)
{
rteptNumber++;
string wptName = "" + rteptNumber;
if (m_routeTrack == null)
{
// first route-making click on the map, create track to hold the new route
string newTrackSource = "route - user created " + DateTime.Now;
Project.trackId++;
rteptNumber = 1;
m_lastWpt = null;
string newTrackName = "Route-" + Project.trackId;
CreateInfo createInfo = new CreateInfo();
createInfo.init("rte");
createInfo.id = Project.trackId;
createInfo.name = newTrackName;
createInfo.source = newTrackSource;
createInfo.par1 = "" + rteNumber;
rteNumber++;
if (rteNumber > 20)
{
rteNumber = 1;
}
m_routeTrack = new Track(createInfo);
m_routeTrack.isRoute = true;
WaypointsCache.TracksAll.Add(m_routeTrack);
wptName = "Start route";
}
m_speed = null;
if (m_lastWpt != null && m_lastWpt.HasSpeed)
{
m_speed = new Speed(m_lastWpt.Speed);
}
else
{
m_speed = new Speed(Project.routeSpeed);
}
TimeSpan dur = new TimeSpan(100000);
Waypoint routeWpt = null;
bool wasNew = false;
if (wpt != null)
{
routeWpt = new Waypoint(wpt);
routeWpt.LiveObjectType = LiveObjectTypes.LiveObjectTypeRoutepoint;
routeWpt.DateTime = m_dateTimeRte;
}
else if (eq != null)
{
//wptName = eq.ToString();
wptName = string.Format("{0:F1} - ", eq.Magn) + eq.sDateTime + " - " + eq.Comment;
routeWpt = new Waypoint(eq.Location, m_dateTimeRte, LiveObjectTypes.LiveObjectTypeRoutepoint, Project.trackId, wptName, eq.Source, eq.Url);
}
else
{
// location must not be null then:
routeWpt = new Waypoint(location, m_dateTimeRte, LiveObjectTypes.LiveObjectTypeRoutepoint, Project.trackId, "", "user created", ""); // no URL
routeWpt.NameDisplayed = wptName;
wasNew = true;
}
if (m_speed != null)
{
routeWpt.Speed = (float)m_speed.Meters;
}
if (m_lastWpt != null && m_lastWpt.TrackId == Project.trackId)
{
Distance dist = routeWpt.distanceFrom(m_lastWpt.Location);
double durSeconds = m_speed.Meters <= 0.0d ? 0.000001d : (dist.Meters / m_speed.Meters * 3600.0d);
dur = new TimeSpan((long)(durSeconds * 10000000.0d));
m_dateTimeRte += dur;
}
routeWpt.DateTime = m_dateTimeRte;
m_lastWpt = routeWpt;
// we need to make sure that the point added is different from the last point in track.
// Magellan will not accept routes with zero-length legs.
Waypoint lastWpt = null;
if (m_routeTrack.Trackpoints.Count > 0)
{
lastWpt = (Waypoint)m_routeTrack.Trackpoints.GetByIndex(m_routeTrack.Trackpoints.Count - 1);
}
if (lastWpt == null || lastWpt.Location.distanceFrom(routeWpt.Location).Meters > 2.0d)
{
if (wasNew && lastWpt != null)
{
routeWpt.Location.Elev = lastWpt.Location.Elev;
}
m_routeTrack.Trackpoints.Add(routeWpt.DateTime, routeWpt);
m_routeTrack.PutOnMap(this, null, this);
if (wptName.Length > 2)
{
//m_cameraManager.MarkLocation(mouseGeoLocation, 0);
m_cameraManager.ProcessCameraMove(); // make sure label is positionsed on the map
}
else
{
// invalidate picture region around just created leg:
Waypoint prevWpt = (Waypoint)m_routeTrack.Trackpoints.GetByIndex(m_routeTrack.Trackpoints.Count - 2);
Point p1 = m_cameraManager.toPixelLocation(routeWpt.Location, null);
Point p2 = m_cameraManager.toPixelLocation(prevWpt.Location, null);
int x = Math.Min(p1.X, p2.X);
int y = Math.Min(p1.Y, p2.Y);
int w = Math.Abs(p1.X - p2.X);
int h = Math.Abs(p1.Y - p2.Y);
Rectangle toInv = new Rectangle(x, y, w, h);
toInv.Offset(-5, -5);
toInv.Inflate(10, 10);
m_pictureManager.Invalidate(toInv);
}
}
}
/// <summary>
/// Signals the start of the transmission.
/// </summary>
public void Begin()
{
MessageRate.Start();
Speed.Start();
}
/// <summary>
/// Sets new measurement speed
/// </summary>
/// <param name="speed">Speed</param>
public void SetSpeed(Speed speed)
{
Set(Commands.Speed, (int)speed);
}
/// <summary>
/// Adds 2D transition with constant speed.
/// </summary>
/// <param name="distanceX">Distance along X axis in steps.</param>
/// <param name="distanceY">Distance along Y axis in steps.</param>
/// <param name="transitionSpeed">Speed of the transition.</param>
public void AddConstantSpeedTransitionXY(int distanceX, int distanceY, Speed transitionSpeed)
{
checked
{
var sqrt = Math.Sqrt(1.0 * distanceX * distanceX + 1.0 * distanceY * distanceY);
var transitionTime = (long)(sqrt * transitionSpeed.Ticks / transitionSpeed.StepCount);
var remainingStepsX = distanceX;
var remainingStepsY = distanceY;
var chunkLengthLimit = 31500;
var chunkCount = 1.0 * Math.Max(Math.Abs(distanceX), Math.Abs(distanceY)) / chunkLengthLimit;
chunkCount = Math.Max(1, chunkCount);
var doneDistanceX = 0L;
var doneDistanceY = 0L;
var doneTime = 0.0;
var i = Math.Min(1.0, chunkCount);
while (Math.Abs(remainingStepsX) > 0 || Math.Abs(remainingStepsY) > 0)
{
var chunkDistanceX = distanceX * i / chunkCount;
var chunkDistanceY = distanceY * i / chunkCount;
var chunkTime = transitionTime * i / chunkCount;
var stepCountXD = chunkDistanceX - doneDistanceX;
var stepCountYD = chunkDistanceY - doneDistanceY;
var stepsTime = chunkTime - doneTime;
var stepCountX = (Int16)Math.Round(stepCountXD);
var stepCountY = (Int16)Math.Round(stepCountYD);
doneDistanceX += stepCountX;
doneDistanceY += stepCountY;
//we DON'T want to round here - this way we can distribute time precisely
var stepTimeX = stepCountX == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountX));
var stepTimeY = stepCountY == 0 ? 0 : (int)(stepsTime / Math.Abs(stepCountY));
var timeRemainderX = Math.Abs(stepCountXD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountXD));
var timeRemainderY = Math.Abs(stepCountYD) <= 1 ? (UInt16)0 : (UInt16)(stepsTime % Math.Abs(stepCountYD));
if (stepTimeX == 0 && stepTimeY == 0)
{
if (doneDistanceX == distanceX && doneDistanceY == distanceY)
{
break;
}
throw new NotImplementedException("Send wait signal");
}
doneTime += stepsTime;
var xPart = createConstant(stepCountX, stepTimeX, timeRemainderX);
var yPart = createConstant(stepCountY, stepTimeY, timeRemainderY);
AddXY(xPart, yPart);
i = i + 1 > chunkCount ? chunkCount : i + 1;
}
}
}
public void DensityTimesSpeedEqualsMassFlux()
{
MassFlux massFlux = Density.FromKilogramsPerCubicMeter(20) * Speed.FromMetersPerSecond(2);
Assert.Equal(massFlux, MassFlux.FromKilogramsPerSecondPerSquareMeter(40));
}
private string FormatSpeed()
{
return(Speed.ToString("0.00", CultureInfo.InvariantCulture.NumberFormat));
}
public static void DragFromTo(this AndroidApp app, float xStart, float yStart, float xEnd, float yEnd, Speed speed = Speed.Fast)
{
// No effect on Android
app.DragCoordinates(xStart, yStart, xEnd, yEnd);
}
/// <summary>
/// Serializes the specified fields of the position record into a string suitable for logging or transmitting.
/// </summary>
/// <param name="fields">A <see cref="GeoFixField" /> bitmap describing the fields to be written.</param>
/// <returns>The serialized record.</returns>
public string ToString(GeoFixField fields)
{
return(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9}",
(fields & GeoFixField.TimeUtc) != 0 && TimeUtc.HasValue ? Serialize.ToString(TimeUtc.Value) : string.Empty,
(fields & GeoFixField.Latitude) != 0 && !double.IsNaN(Latitude) ? Latitude.ToString() : string.Empty,
(fields & GeoFixField.Longitude) != 0 && !double.IsNaN(Longitude) ? Longitude.ToString() : string.Empty,
(fields & GeoFixField.Altitude) != 0 && !double.IsNaN(Altitude) ? Altitude.ToString() : string.Empty,
(fields & GeoFixField.Course) != 0 && !double.IsNaN(Course) ? Course.ToString() : string.Empty,
(fields & GeoFixField.Speed) != 0 && !double.IsNaN(Speed) ? Speed.ToString() : string.Empty,
(fields & GeoFixField.HorizontalAccuracy) != 0 && !double.IsNaN(HorizontalAccuracy) ? HorizontalAccuracy.ToString() : string.Empty,
(fields & GeoFixField.VerticalAccurancy) != 0 && !double.IsNaN(VerticalAccurancy) ? VerticalAccurancy.ToString() : string.Empty,
(fields & GeoFixField.Technology) != 0 && Technology != GeoFixTechnology.Unknown ? Technology.ToString() : string.Empty,
(fields & GeoFixField.NetworkStatus) != 0 && NetworkStatus != NetworkStatus.Unknown ? NetworkStatus.ToString() : string.Empty));
}
/// <summary>Initializes a new instance of the <seealso cref="SpeedSegment"/> class.</summary>
/// <param name="speed">The speed of the speed segment.</param>
/// <param name="x">The starting X of the speed segment.</param>
public SpeedSegment(Speed speed, double x)
{
Speed = speed;
X = x;
}
public Pickup(float x, float y, Int16 type)
: base(x, y)
{
this.PickupType = type;
switch (type)
{
case (int)PickupManager.PICKUPTYPES.UPGRADE_WEAPON_PRIMARY:
img = new Image(Assets.GRAPHIC_PICKUP_UPGRADE_WEAPON_PRIMARY);
break;
case (int)PickupManager.PICKUPTYPES.AMMO_ROCKET:
img = new Image(Assets.GRAPHIC_PICKUP_AMMO_ROCKET);
break;
case (int)PickupManager.PICKUPTYPES.POWERUP_INV:
img = new Image(Assets.GRAPHIC_PICKUP_POWERUP_INV);
break;
case (int)PickupManager.PICKUPTYPES.POWERUP_HEALTH:
img = new Image(Assets.GRAPHIC_PICKUP_POWERUP_HEALTH);
break;
case (int)PickupManager.PICKUPTYPES.POWERUP_LEVEL_UP:
img = new Image(Assets.GRAPHIC_PICKUP_POWERUP_LEVEL_UP);
break;
case (int)PickupManager.PICKUPTYPES.POWERUP_PLAYER_SHIP:
img = new Image(Assets.GRAPHIC_PICKUP_POWERUP_PLAYER_SHIP);
break;
case (int)PickupManager.PICKUPTYPES.DEGRADE_WEAPON_PRIMARY:
img = new Image(Assets.GRAPHIC_PICKUP_DEGRADE_WEAPON_PRIMARY);
break;
case (int)PickupManager.PICKUPTYPES.AMMO_ROCKET_LOOSE:
img = new Image(Assets.GRAPHIC_PICKUP_AMMO_ROCKET_LOOSE);
break;
case (int)PickupManager.PICKUPTYPES.DEGRADE_50HEALTH:
img = new Image(Assets.GRAPHIC_PICKUP_DEGRADE_50HEALTH);
break;
case (int)PickupManager.PICKUPTYPES.UPGRADE_SPEED:
img = new Image(Assets.GRAPHIC_PICKUP_UPGRADE_SPEED);
break;
case (int)PickupManager.PICKUPTYPES.DEGRAGE_SPEED:
img = new Image(Assets.GRAPHIC_PICKUP_DEGRADE_SPEED);
break;
default:
img = Image.CreateRectangle(5, Color.Red);
break;
}
this.X = x;
this.Y = y;
this.speed = new Speed(Global.SPEED_PICKUP_MAX);
this.speed.Y = Rand.Int(2, Global.SPEED_PICKUP_MAX);
img.CenterOrigin();
this.SetGraphic(img);
CircleCollider col = new CircleCollider((int)this.img.HalfWidth, (int)Global.HIT_TYPES.PICKUP);
col.CenterOrigin();
this.AddCollider(col);
}
public HumanMouse(DeviceControl control, Speed speed)
{
this.speed = speed;
this.control = control;
}
/// <summary>
/// Creates a GprmcSentence from the specified parameters
/// </summary>
/// <param name="utcDateTime"></param>
/// <param name="isFixAcquired"></param>
/// <param name="position"></param>
/// <param name="speed"></param>
/// <param name="bearing"></param>
/// <param name="magneticVariation"></param>
public GprmcSentence(DateTime utcDateTime, bool isFixAcquired, Position position, Speed speed, Azimuth bearing, Longitude magneticVariation)
{
// Use a string builder to create the sentence text
StringBuilder builder = new StringBuilder(128);
/* GPRMC sentences have the following format:
*
* $GPRMC,040302.663,A,3939.7,N,10506.6,W,0.27,358.86,200804,,*1A
*/
// Append the command word, $GPRMC
builder.Append("$GPRMC");
// Append a comma
builder.Append(',');
#region Append the UTC time
builder.Append(utcDateTime.Hour.ToString("0#", NmeaCultureInfo));
builder.Append(utcDateTime.Minute.ToString("0#", NmeaCultureInfo));
builder.Append(utcDateTime.Second.ToString("0#", NmeaCultureInfo));
builder.Append(".");
builder.Append(utcDateTime.Millisecond.ToString("00#", NmeaCultureInfo));
#endregion
// Append a comma
builder.Append(',');
#region Append the fix status
// Write fix information
if (isFixAcquired)
{
builder.Append("A");
}
else
{
builder.Append("V");
}
#endregion
// Append a comma
builder.Append(',');
#region Append the position
// Append latitude in the format HHMM.MMMM.
builder.Append(position.Latitude.ToString("HHMM.MMMM,I,", NmeaCultureInfo));
// Append Longitude in the format HHHMM.MMMM.
builder.Append(position.Longitude.ToString("HHHMM.MMMM,I,", NmeaCultureInfo));
#endregion
// Append the speed (in knots)
builder.Append(speed.ToKnots().ToString("v.v", NmeaCultureInfo));
// Append a comma
builder.Append(',');
// Append the bearing
builder.Append(bearing.ToString("d.d", NmeaCultureInfo));
// Append a comma
builder.Append(',');
#region Append the UTC date
// Append UTC date
builder.Append(utcDateTime.Day.ToString("0#", NmeaCultureInfo));
builder.Append(utcDateTime.Month.ToString("0#", NmeaCultureInfo));
// Append the year (year minus 2000)
int year = utcDateTime.Year - 2000;
builder.Append(year.ToString("0#", NmeaCultureInfo));
#endregion
// Append a comma
builder.Append(',');
// Append magnetic variation
builder.Append(magneticVariation.ToString("d.d", NmeaCultureInfo));
// Set this object's sentence
SetSentence(builder.ToString());
// Finally, append the checksum
AppendChecksum();
}
public override void Update(GameForm form)
{
if (Speed.Length > 0)
{
Speed -= Speed.Normalize() * 1.5;
}
if (Speed.Length > 8)
{
Speed = Speed.Normalize() * 8;
}
if (form.GameSpace.Map[Column, Row].Block is Ladder)
{
if (Spacing.Length < 10)
{
Speed = Vector.Zero;
}
if (actions.Contains(Action.Climb))
{
if (direction == Direction.Up)
{
if (Speed.Y > -4)
{
Speed += new Vector(0, -4);
}
}
if (direction == Direction.Down)
{
if (Speed.Y < 4)
{
Speed += new Vector(0, 4);
}
}
if (direction == Direction.Left)
{
if (Speed.X > -4)
{
Speed += new Vector(-4, 0);
}
}
if (direction == Direction.Right)
{
if (Speed.X < 4)
{
Speed += new Vector(4, 0);
}
}
}
}
else
{
Speed += new Vector(0, 3);
if (actions.Contains(Action.Run))
{
if (direction == Direction.Left)
{
if (Speed.X > -4)
{
Speed += new Vector(-4, 0);
}
}
if (direction == Direction.Right)
{
if (Speed.X < 4)
{
Speed += new Vector(4, 0);
}
}
}
if (actions.Contains(Action.Jump))
{
if (form.GameSpace.Map[Column, Row].Bottom != null)
{
if (!form.GameSpace.Map[Column, Row].Bottom.IsPermeable && Spacing.Y < 3)
{
Jump();
}
}
}
}
Move(form);
if (Row == 11)
{
Destroy();
}
base.Update(form);
}
protected override void OnSentenceChanged()
{
// First, process the basic info for the sentence
base.OnSentenceChanged();
// Cache the sentence words
string[] words = base.Words;
int wordCount = words.Length;
/*
* $GPRMC
*
* Recommended minimum specific GPS/Transit data
*
* eg1. $GPRMC,081836,A,3751.65,S,14507.36,E,000.0,360.0,130998,011.3,E*62
* eg2. $GPRMC,225446,A,4916.45,N,12311.12,W,000.5,054.7,191194,020.3,E*68
*
*
* 225446 Time of fix 22:54:46 UTC
* A Navigation receiver warning A = OK, V = warning
* 4916.45,N Latitude 49 deg. 16.45 min North
* 12311.12,W Longitude 123 deg. 11.12 min West
* 000.5 Speed over ground, Knots
* 054.7 Course Made Good, True
* 191194 Date of fix 19 November 1994
* 020.3,E Magnetic variation 20.3 deg East
* 68 mandatory checksum
*
*
* eg3. $GPRMC,220516,A,5133.82,N,00042.24,W,173.8,231.8,130694,004.2,W*70
* 1 2 3 4 5 6 7 8 9 10 11 12
*
*
* 1 220516 Time Stamp
* 2 A validity - A-ok, V-invalid
* 3 5133.82 current Latitude
* 4 N North/South
* 5 00042.24 current Longitude
* 6 W East/West
* 7 173.8 Speed in knots
* 8 231.8 True course
* 9 130694 Date Stamp
* 10 004.2 Variation
* 11 W East/West
* 12 *70 checksum
*
*
* eg4. $GPRMC,hhmmss.ss,A,llll.ll,a,yyyyy.yy,a,x.x,x.x,ddmmyy,x.x,a*hh
* 1 = UTC of position fix
* 2 = Data status (V=navigation receiver warning)
* 3 = Latitude of fix
* 4 = N or S
* 5 = Longitude of fix
* 6 = E or W
* 7 = Speed over ground in knots
* 8 = Track made good in degrees True
* 9 = UT date
* 10 = Magnetic variation degrees (Easterly var. subtracts from true course)
* 11 = E or W
* 12 = Checksum
*/
// Do we have enough words to parse the fix status?
if (wordCount >= 2 && words[1].Length != 0)
{
#region Fix status
// Get the fix flag
_FixStatus = words[1].Equals("A", StringComparison.OrdinalIgnoreCase) ? FixStatus.Fix : FixStatus.NoFix;
#endregion
}
else
{
// The fix status is invalid
_FixStatus = FixStatus.Unknown;
}
// Do we have enough words to parse the UTC date/time?
if (wordCount >= 9 && words[0].Length != 0 && words[8].Length != 0)
{
#region Parse the UTC time
string utcTimeWord = words[0];
int utcHours = int.Parse(utcTimeWord.Substring(0, 2), NmeaCultureInfo); // AA
int utcMinutes = int.Parse(utcTimeWord.Substring(2, 2), NmeaCultureInfo); // BB
int utcSeconds = int.Parse(utcTimeWord.Substring(4, 2), NmeaCultureInfo); // CC
int utcMilliseconds = 0;
if (utcTimeWord.Length > 6)
{
utcMilliseconds = Convert.ToInt32(float.Parse(utcTimeWord.Substring(6), NmeaCultureInfo) * 1000, NmeaCultureInfo); // DDDD
}
#endregion
#region Parse the UTC date
string utcDateWord = words[8];
int utcDay = int.Parse(utcDateWord.Substring(0, 2), NmeaCultureInfo);
int utcMonth = int.Parse(utcDateWord.Substring(2, 2), NmeaCultureInfo);
int utcYear = int.Parse(utcDateWord.Substring(4, 2), NmeaCultureInfo) + 2000;
#endregion
#region Build a UTC date/time
_UtcDateTime = new DateTime(utcYear, utcMonth, utcDay, utcHours, utcMinutes, utcSeconds, utcMilliseconds, DateTimeKind.Utc);
#endregion
}
else
{
// The UTC date/time is invalid
_UtcDateTime = DateTime.MinValue;
}
// Do we have enough data to parse the location?
if (wordCount >= 6 && words[2].Length != 0 && words[3].Length != 0 && words[4].Length != 0 && words[5].Length != 0)
{
#region Parse the latitude
string latitudeWord = words[2];
int latitudeHours = int.Parse(latitudeWord.Substring(0, 2), NmeaCultureInfo);
double latitudeDecimalMinutes = double.Parse(latitudeWord.Substring(2), NmeaCultureInfo);
LatitudeHemisphere latitudeHemisphere =
words[3].Equals("N", StringComparison.Ordinal) ? LatitudeHemisphere.North : LatitudeHemisphere.South;
#endregion
#region Parse the longitude
string longitudeWord = words[4];
int longitudeHours = int.Parse(longitudeWord.Substring(0, 3), NmeaCultureInfo);
double longitudeDecimalMinutes = double.Parse(longitudeWord.Substring(3), NmeaCultureInfo);
LongitudeHemisphere longitudeHemisphere =
words[5].Equals("E", StringComparison.Ordinal) ? LongitudeHemisphere.East : LongitudeHemisphere.West;
#endregion
#region Build a Position from the latitude and longitude
_Position = new Position(
new Latitude(latitudeHours, latitudeDecimalMinutes, latitudeHemisphere),
new Longitude(longitudeHours, longitudeDecimalMinutes, longitudeHemisphere));
#endregion
}
else
{
_Position = Position.Invalid;
}
// Do we have enough info to process speed?
if (wordCount >= 7 && words[6].Length != 0)
{
#region Speed
// The speed is the sixth word, expressed in knots
_Speed = new Speed(double.Parse(words[6], NmeaCultureInfo), SpeedUnit.Knots);
#endregion
}
else
{
// The speed is invalid
_Speed = Speed.Invalid;
}
// do we have enough info to process the bearing?
if (wordCount >= 8 && words[7].Length != 0)
{
#region Bearing
// The bearing is the seventh word
_Bearing = new Azimuth(double.Parse(words[7], NmeaCultureInfo));
#endregion
}
else
{
// The bearing is invalid
_Bearing = Azimuth.Invalid;
}
// Do we have enough info for magnetic variation?
if (wordCount >= 10 && words[9].Length != 0)
{
// Parse the value
_MagneticVariation = new Longitude(double.Parse(words[9], NmeaCultureInfo));
}
else
{
// The magnetic variation is invalid
_MagneticVariation = Longitude.Invalid;
}
}
protected override void SolveInstance(IGH_DataAccess DA)
{
DA.GetData("Calculate", ref this._calc);
if (!this._calc)
{
DA.SetDataList("Targets", this._targets);
DA.SetData("Path", this._path);
//DA.SetDataList("Planes", this._planes);
DA.SetData("debug", this._debug);
return;
}
this._debug = "";
this._path = null;
this._targets = null;
this._planes = null;
Plane frame_t = new Plane();
this._toolpaths = new List <Polyline>();
// collect inputs
DA.GetData("Workplane", ref this._workplane);
DA.GetData("External axes", ref this._extern);
DA.GetData("Configuration", ref this._config);
if (!DA.GetData("Frame", ref frame_t))
{
_frame = Frame.Default;
}
//_frame = new Frame(Plane.WorldXY, "tasFrame");
else
{
_frame = new Frame(frame_t, -1, -1, "tasFrame");
}
Robots.Grasshopper.GH_Tool toolGH = null;
DA.GetData("Tool", ref toolGH);
this._tool = toolGH?.Value;
this._debug += toolGH.ToString() + "\n";
this._debug += toolGH.GetType().ToString() + "\n";
if (this._tool == null)
{
this._debug += "Tool conversion failed...\n";
}
else
{
this._debug += this._tool.ToString() + "\n";
this._debug += this._tool.GetType().ToString() + "\n";
}
// gather and convert, if necessary, input curves
List <Curve> in_crvs = new List <Curve>();
if (!DA.GetDataList("Toolpaths", in_crvs))
{
return;
}
this._toolpaths = tasUtility.CurvesToPolylines(in_crvs, 1.0);
this._is_drive_surface = DA.GetData("DriveSurface", ref this._drive_surface);
DA.GetData("Safe Z", ref this._safe_z);
DA.GetData("Rapid Z", ref this._rapid_z);
DA.GetData("Feed rate", ref this._feedrate);
DA.GetData("Rapid rate", ref this._rapidrate);
DA.GetData("Ramp height", ref this._ramp_height);
DA.GetData("Tool twist", ref this._tooltwist);
// /collect inputs
// set up speeds
Speed sp_feed = new Speed(this._feedrate, Math.PI, "feed");
Speed sp_rapid = new Speed(this._rapidrate, Math.PI, "rapid");
// rotate workplane to account for tool twist
Transform rot = Transform.Rotation(this._tooltwist, _workplane.ZAxis, _workplane.Origin);
_workplane.Transform(rot);
// init toolpath
Toolpath prog = new Toolpath();
prog.External2 = this._extern;
prog.External1 = this._extern;
prog.Configuration = (Target.RobotConfigurations) this._config;
prog.DefFrame = _frame;
if (this._tool != null)
{
prog.DefTool = this._tool;
}
else
{
this._debug += "Tool conversion failed again...\n";
}
prog.DefSpeed = sp_rapid;
prog.DefMotion = Target.Motions.Linear;
if (this._is_drive_surface)
{
prog.InputSurface = this._drive_surface;
}
prog.Orientation = Toolpath.ToolOrientation.SurfaceNormal;
prog.Workplane = this._workplane;
for (int i = 0; i < this._toolpaths.Count; ++i)
{
if (this._toolpaths[i] == null)
{
continue;
}
// lead in
Polyline ramp = (Polyline)Util.CreateRamp(this._toolpaths[i], this._workplane, this._ramp_height, this._ramp_height * 5);
Point3d p = Util.ProjectToPlane(ramp[0], prog.Workplane);
prog.CreateTarget(p + prog.Workplane.ZAxis * (this._safe_z + this._rapid_z));
prog.CreateTarget(p + prog.Workplane.ZAxis * (this._safe_z));
// machining speed
prog.DefSpeed = sp_feed;
prog.DefMotion = Target.Motions.Linear;
for (int j = 0; j < ramp.Count; ++j)
{
prog.CreateTarget(ramp[j], Toolpath.ToolOrientation.ZAxis);
}
/*
* Point3d p = tasUtility.ProjectToPlane(this._toolpaths[i][0], prog.Workplane);
* Vector3d d2p = new Vector3d(p - this._toolpaths[i][0]);
* Vector3d ramp = new Vector3d(tasUtility.ProjectToPlane(this._toolpaths[i][1], prog.Workplane) - p);
* if (ramp.Length < this._ramp_height)
* ramp = new Vector3d(tasUtility.ProjectToPlane(this._toolpaths[i][this._toolpaths[i].Count - 2], prog.Workplane) - p);
* ramp.Unitize();
* p += ramp * this._ramp_height;
* p += prog.Workplane.ZAxis * (this._safe_z + this._rapid_z);
* prog.CreateTarget(p, Toolpath.ToolOrientation.ZAxis);
* p -= prog.Workplane.ZAxis * this._rapid_z;
* p -= d2p;
* prog.CreateTarget(p, Toolpath.ToolOrientation.ZAxis);
*/
// make toolpath targets
for (int j = 0; j < this._toolpaths[i].Count; ++j)
{
prog.CreateTarget(this._toolpaths[i][j]);
}
// lead out
Point3d p2 = Util.ProjectToPlane(this._toolpaths[i][this._toolpaths[i].Count - 1], prog.Workplane);
p2 += prog.Workplane.ZAxis * this._safe_z;
prog.DefSpeed = sp_rapid;
prog.CreateTarget(p2, Toolpath.ToolOrientation.ZAxis);
p2 += prog.Workplane.ZAxis * this._rapid_z;
//prog.DefSpeed = spr;
prog.CreateTarget(p2, Toolpath.ToolOrientation.ZAxis);
}
// yield toolpath
this._targets = prog.Targets;
this._path = prog.Path();
this._planes = prog.Planes;
DA.SetDataList("Targets", this._targets);
DA.SetData("Path", this._path);
//DA.SetDataList("Planes", this._planes);
DA.SetData("debug", this._debug);
}
public void StartRace(params Car[] cars)
{
int distance;
bool status;
do
{
Console.Write("Enter distance (meters): ");
string d = Console.ReadLine();
status = int.TryParse(d, out distance);
if (status)
{
distance = int.Parse(d);
}
} while (!status || distance == 0);
// Starting timer here >>
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
string s = String.Format("{0} ", "TIME".PadRight(10));
int i = 0;
foreach (Car car in cars)
{
s += String.Format("{0} {1} | {2} ", car.Brand.PadLeft(10), "SPEED".PadRight(10), "DISTANCE".PadRight(5));
}
Console.WriteLine(s);
s = "";
Random rand = new Random();
while (!this.IsOver(distance, cars))
{
i++;
s = String.Format("{0, 7}{1:3}", (i + 1) * 10000, Time.Format.SEC.ToString().ToLower());
foreach (Car car in cars)
{
car.Acceleration = rand.Next(-20, 21);
if (car.Speed + car.Acceleration > 0)
{
car.Speed += car.Acceleration;
car.DistanceTravelled += car.SetDistanceTravelled(car.Speed);
}
else
{
car.Speed = 0;
car.DistanceTravelled += car.SetDistanceTravelled(car.Speed);
}
s += String.Format("{0} {1} {2} | {3}M", "".PadRight(10), car.Speed.ToString().PadRight(5),
Speed.KMxHR().Value, car.DistanceTravelled.ToString().PadRight(4)); // change this
}
Thread.Sleep(500);
Console.WriteLine(s);
s = "";
}
// Ending timer here >>
stopwatch.Stop();
Console.WriteLine(stopwatch.Elapsed);
}
public void MassFluxDividedBySpeedEqualsDensity()
{
Density density = MassFlux.FromKilogramsPerSecondPerSquareMeter(20) / Speed.FromMetersPerSecond(2);
Assert.Equal(density, Density.FromKilogramsPerCubicMeter(10));
}
public Wind()
{
Speed = new Speed();
}
