//TODO use same action for GetBallsBeforeCount and GetHoleForBall //TODO Linq can cause bad performance for big collections. THink about optimizations private int GetBallsBeforeCount(Field field, TiltDirection direction, Ball ball) { switch (direction) { case TiltDirection.North: return(field.Balls.Count(x => !x.HoleId.HasValue && x.Coordinates.X == ball.Coordinates.X && x.Coordinates.Y > ball.Coordinates.Y)); case TiltDirection.South: return(field.Balls.Count(x => !x.HoleId.HasValue && x.Coordinates.X == ball.Coordinates.X && x.Coordinates.Y < ball.Coordinates.Y)); case TiltDirection.West: return(field.Balls.Count(x => !x.HoleId.HasValue && x.Coordinates.Y == ball.Coordinates.Y && x.Coordinates.X < ball.Coordinates.X)); case TiltDirection.East: default: return(field.Balls.Count(x => !x.HoleId.HasValue && x.Coordinates.Y == ball.Coordinates.Y && x.Coordinates.X > ball.Coordinates.X)); } }
private void TiltShip(TiltDirection direction) { if (direction == TiltDirection.None && tiltAxisStep != 0) { if (tiltAxisStep < 0) { tiltAxisStep += 0.2f; } if (tiltAxisStep > 0) { tiltAxisStep -= 0.2f; } } else if (direction == TiltDirection.Left && tiltAxisStep > -1.0f) { tiltAxisStep -= 0.1f; if (tiltAxisStep < -1.0f) { tiltAxisStep = -1.0f; } } else if (direction == TiltDirection.Right && tiltAxisStep < 1.0f) { tiltAxisStep += 0.1f; if (tiltAxisStep > 1.0f) { tiltAxisStep = 1.0f; } } spaceShip.transform.Rotate(tiltAxisStep * (-tiltAxis) - spaceShip.transform.eulerAngles.x, 0, 0); }
private Hole GetHoleForBall(Field field, TiltDirection direction, Ball ball) { switch (direction) { case TiltDirection.North: return(field.Holes.Where(x => !x.BallId.HasValue && x.Coordinates.X == ball.Coordinates.X && x.Coordinates.Y > ball.Coordinates.Y). OrderBy(x => x.Coordinates.Y).FirstOrDefault()); case TiltDirection.South: return(field.Holes.Where(x => !x.BallId.HasValue && x.Coordinates.X == ball.Coordinates.X && x.Coordinates.Y < ball.Coordinates.Y). OrderByDescending(x => x.Coordinates.Y).FirstOrDefault()); case TiltDirection.West: return(field.Holes.Where(x => !x.BallId.HasValue && x.Coordinates.Y == ball.Coordinates.Y && x.Coordinates.X < ball.Coordinates.X). OrderByDescending(x => x.Coordinates.X).FirstOrDefault()); case TiltDirection.East: default: return(field.Holes.Where(x => !x.BallId.HasValue && x.Coordinates.Y == ball.Coordinates.Y && x.Coordinates.X > ball.Coordinates.X). OrderBy(x => x.Coordinates.Y).FirstOrDefault()); } }
/// <summary> /// Invokes action of an ended tilt with the given tilt direction. /// </summary> /// <param name="direction">Direction of the ended tilt.</param> private static void InvokeEndedTiltAction(TiltDirection direction) { switch (direction) { case TiltDirection.RIGHT: OnEndedTiltRight?.Invoke(); break; case TiltDirection.LEFT: OnEndedTiltLeft?.Invoke(); break; case TiltDirection.FORWARD: OnEndedTiltForward?.Invoke(); break; case TiltDirection.BACKWARD: OnEndedTiltBackward?.Invoke(); break; case TiltDirection.NONE: default: break; } }
/// <summary> /// Invoke ongoing tilt actions dependent on the given direction. /// </summary> /// <param name="direction">Direction of the tilt</param> /// <param name="tiltMovement">Current movement of the device.</param> private static void InvokeOngoingTiltDirectionAction(TiltDirection direction, IVectorMovementInputArgs tiltMovement) { switch (direction) { case TiltDirection.RIGHT: OnOngoingTiltRight?.Invoke(tiltMovement); break; case TiltDirection.LEFT: OnOngoingTiltLeft?.Invoke(tiltMovement); break; case TiltDirection.FORWARD: OnOngoingTiltForward?.Invoke(tiltMovement); break; case TiltDirection.BACKWARD: OnOngoingTiltBackward?.Invoke(tiltMovement); break; case TiltDirection.NONE: default: return; } }
/// <summary> /// Updates container which tracks ongoing tilts from the previous frame. /// </summary> /// <param name="ongoingTiltDirection">Currently ongoing tilt direction.</param> private static void UpdatePreviousOngoingTilts(TiltDirection ongoingTiltDirection) { if (!previousTilts.Contains(ongoingTiltDirection)) { previousTilts.Add(ongoingTiltDirection); } }
public void Tilt(byte address, TiltDirection direction, byte speedPercent) { var message = _requestBuilder.Tilt(address, direction, getMovementSpeedValue(speedPercent)); _logger.LogDebugMessage($"Tilt {direction} @ {speedPercent} speed => {message}"); _transport.SendMessage(message); }
public override void TiltMove(string VideoSource, TiltDirection Direction, [System.Xml.Serialization.XmlElementAttribute(DataType = "duration")] string Timeout) { ParametersValidation validation = new ParametersValidation(); validation.Add(ParameterType.String, "VideoSource", VideoSource); validation.Add(ParameterType.OptionalString, "Timeout", Timeout); validation.Add(ParameterType.String, "Direction", Direction.ToString()); ExecuteVoidCommand(validation, ProvisioningServiceTest.TiltMoveTest); }
public PelcoDEMessage Tilt(byte address, TiltDirection direction, byte speed) { var cmd = direction switch { TiltDirection.Up => PelcoDEMessageType.TiltUp, TiltDirection.Down => PelcoDEMessageType.TiltDown, _ => throw new ArgumentOutOfRangeException(nameof(direction), direction, null) }; return(buildPanTiltContinuously(address, cmd, speed)); }
void Move(TiltDirection direction, Speed speed) { var data = new byte[] { (byte)(0x80 + Id), 0x01, 0x06, 0x01, 0x00, (byte)speed, 0x03, (byte)direction, 0xff }; _socket.Send(data); }
private Action <Ball> GetTiltAction(TiltDirection direction, int fieldSize, int ballsBefore) { switch (direction) { case TiltDirection.North: return((ball) => ball.Coordinates = new Point(ball.Coordinates.X, fieldSize - 1 - ballsBefore)); case TiltDirection.South: return((ball) => ball.Coordinates = new Point(ball.Coordinates.X, ballsBefore)); case TiltDirection.West: return((ball) => ball.Coordinates = new Point(ballsBefore, ball.Coordinates.Y)); case TiltDirection.East: default: return((ball) => ball.Coordinates = new Point(fieldSize - 1 - ballsBefore, ball.Coordinates.Y)); } }
private List <Ball> GetBallsOrder(Field field, TiltDirection direction) { switch (direction) { case TiltDirection.North: return(field.Balls.Where(x => !x.HoleId.HasValue).OrderByDescending(x => x.Coordinates.Y).ToList()); case TiltDirection.South: return(field.Balls.Where(x => !x.HoleId.HasValue).OrderBy(x => x.Coordinates.Y).ToList()); case TiltDirection.West: return(field.Balls.Where(x => !x.HoleId.HasValue).OrderBy(x => x.Coordinates.X).ToList()); case TiltDirection.East: default: return(field.Balls.Where(x => !x.HoleId.HasValue).OrderByDescending(x => x.Coordinates.X).ToList()); } }
public void Tilt(Field field, TiltDirection direction) { // To check ball-hole collision in correct order for balls in same row\column var sortedBalls = GetBallsOrder(field, direction); foreach (var ball in sortedBalls) { var hole = GetHoleForBall(field, direction, ball); if (hole != null) { field.PutBallInHole(ball, hole); } else { var action = GetTiltAction(direction, field.Size, GetBallsBeforeCount(field, direction, ball)); action?.Invoke(ball); } } }
/// <summary> /// Checks if the tilt was strong enough to pass the treshold values. /// </summary> /// <param name="direction">Direction of the happening tilt.</param> /// <param name="acceleration">Device acceleration of the happening tilt.</param> /// <returns>Was the tilt strong enough to pass the needed treshold values.</returns> private static bool CheckIsTiltValid(TiltDirection direction, Vector2 acceleration) { switch (direction) { case TiltDirection.RIGHT: return(acceleration.x >= loadedSettingsData.xTiltPosThreshold); case TiltDirection.LEFT: return(acceleration.x <= loadedSettingsData.xTiltNegThreshold); case TiltDirection.FORWARD: return(acceleration.y >= loadedSettingsData.yTiltPosThreshold); case TiltDirection.BACKWARD: return(acceleration.y <= loadedSettingsData.yTiltNegThreshold); case TiltDirection.NONE: default: return(false); } }
public abstract void TiltMove(string VideoSource, TiltDirection Direction, [System.Xml.Serialization.XmlElementAttribute(DataType = "duration")] string Timeout);