public bool CanTurnInDirection(TurnDirection direction)
{
switch (direction)
{
case TurnDirection.YawClockwise:
if (torque.y < -.9f)
return true;
break;
case TurnDirection.YawCounterclock:
if (torque.y > .9f)
return true;
break;
case TurnDirection.RollRight:
if (torque.z > .9f)
return true;
break;
case TurnDirection.RollLeft:
if (torque.z < -.9f)
return true;
break;
case TurnDirection.PitchUp:
if (torque.x > .9f)
return true;
break;
case TurnDirection.PitchDown:
if (torque.x < -.9f)
return true;
break;
default:
break;
}
return false;
}
public ExpressConveyorBelt(Board board, Tile baseTile, TileDirection direction, TurnDirection turn, int x,
int y)
: base(board, baseTile, x, y)
{
Direction = direction;
Turn = turn;
}
public static char GetChar(TurnDirection td)
{
switch (td)
{
case TurnDirection.Left:
return 'L';
case TurnDirection.Right:
return 'R';
case TurnDirection.Both:
return 'B';
}
return 'N';
}
public Worm(GamePlayScreen scr, Color col)
{
color = col;
screen = scr;
turning = TurnDirection.None;
spriteBatch = screen.ScreenManager.SpriteBatch;
LoadContent();
Rectangle spawnfield = new Rectangle(100, 100, screen.ScreenManager.Game.GraphicsDevice.Viewport.Width - 120 - 200, screen.ScreenManager.Game.GraphicsDevice.Viewport.Height - 200);
setDirection(360.0 * screen.Random.NextDouble());
head_position = new Vector2(spawnfield.Left + spawnfield.Width * (float)screen.Random.NextDouble(),
spawnfield.Top + spawnfield.Height * (float)screen.Random.NextDouble());
AddPoint(CurrentVector());
}
public async Task TurnAsync(int degree, TurnDirection direction,
DrivingMethod drivingMethod = DrivingMethod.FullStep)
{
int steps;
GpioPinValue[][] methodSequence;
switch (drivingMethod)
{
case DrivingMethod.WaveDrive:
methodSequence = _waveDriveSequence;
steps = (int)Math.Ceiling(degree / 0.1767478397486253);
break;
case DrivingMethod.FullStep:
methodSequence = _fullStepSequence;
steps = (int)Math.Ceiling(degree / 0.1767478397486253);
break;
case DrivingMethod.HalfStep:
methodSequence = _haveStepSequence;
steps = (int)Math.Ceiling(degree / 0.0883739198743126);
break;
default:
throw new ArgumentOutOfRangeException(nameof(drivingMethod), drivingMethod, null);
}
var counter = 0;
while (counter < steps)
{
for (var j = 0; j < methodSequence[0].Length; j++)
{
for (var i = 0; i < 4; i++)
{
_gpioPins[i].Write(methodSequence[direction == TurnDirection.Right ? i : 3 - i][j]);
}
await Task.Delay(5);
counter++;
if (counter == steps)
break;
}
}
Stop();
}
public Dictionary<CommandFields, short> Update(Robot robot, MonteCarloLocalization localization, Stopwatch stopwatch)
{
Dictionary<CommandFields, short> outputState = new Dictionary<CommandFields, short>();
// Check for start pulse
if (!started)
{
// Set flag
started = true;
// Record start time
startTime = stopwatch.ElapsedMilliseconds;
// Set state
state = AlgorithmState.LiftingScoop;
}
switch (state)
{
case AlgorithmState.LiftingScoop:
// Check arm swing limit
if (robot.TelemetryFeedback.ScoopUpperLimitSwitchDepressed)
{
Console.WriteLine("Lifting scoop");
// Move to next stage
state = AlgorithmState.Spinning;
// Save time
startTime = stopwatch.ElapsedMilliseconds;
// Set state
outputState[Comms.CommandEncoding.CommandFields.TranslationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.RotationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.BucketPivot] = 0;
}
else
{
Console.WriteLine("Scoop lifted");
// Set state
outputState[Comms.CommandEncoding.CommandFields.TranslationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.RotationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.BucketPivot] = 1000;
}
break;
case AlgorithmState.Spinning:
long elapsedTime = stopwatch.ElapsedMilliseconds - startTime;
if (elapsedTime > configuration.LocalizationTurnDuration)
{
// Change direction
if (turnDirection == TurnDirection.Left)
turnDirection = TurnDirection.Right;
else
turnDirection = TurnDirection.Left;
// Reset start timer
startTime = stopwatch.ElapsedMilliseconds;
}
// Check convergence of MCL
if (localization.Confidence > configuration.DesiredLocalizationConfidence)
{
Console.WriteLine("MCL converged");
// Set flag
state = AlgorithmState.Done;
// Set state
outputState[Comms.CommandEncoding.CommandFields.TranslationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.RotationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.BucketPivot] = 0;
}
else
{
Console.WriteLine("Spinning in place, MCL confidence: " + localization.Confidence);
// Set static state
outputState[Comms.CommandEncoding.CommandFields.TranslationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.RotationalVelocity] = (short)turnDirection;
outputState[Comms.CommandEncoding.CommandFields.BucketPivot] = 0;
// Check reinitialize
if (elapsedTime > configuration.ConvergenceAllowance)
{
// Reinitialize the MCL algorithm
localization.Initialize(robot);
// Reset timer
startTime = stopwatch.ElapsedMilliseconds;
}
}
break;
case AlgorithmState.Done:
// Set state
outputState[Comms.CommandEncoding.CommandFields.TranslationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.RotationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.BucketPivot] = 1000;
break;
default:
break;
}
// Static state
outputState[Comms.CommandEncoding.CommandFields.BucketPitch] = 0;
outputState[Comms.CommandEncoding.CommandFields.LeftBucketActuator] = 0;
outputState[Comms.CommandEncoding.CommandFields.RightBucketActuator] = 0;
outputState[Comms.CommandEncoding.CommandFields.RangeFinderServo] = 90;
return outputState;
}
public void Turn(TurnDirection turn)
{
if (driveAvailable)
{
int enlarger = turn == TurnDirection.CW ? 1 : -1;
for (int i = 0; i <= 1; i++)
{
if (Math.Abs(driveWheels[i].Angle.Y + enlarger) <= 30)
driveWheels[i].Angle.Y += enlarger;
}
if (speed != 0)
this.Angle.Y += enlarger;
turnFlag = true;
frame = 0;
}
}
public void Update(GameTime gameTime)
{
if (screen.TransitionPosition == 0)
{
//Hole?
if (!making_hole && screen.Random.NextDouble() < Settings.Worm.hole_chance)
{
making_hole = true;
hole_begin_time = gameTime.TotalGameTime.Ticks;
}
else if (making_hole && gameTime.TotalGameTime.Ticks > Settings.Worm.hole_time + hole_begin_time)
{
making_hole = false;
hole_begin_time = 0;
}
//Turning
if (turning != TurnDirection.None)
{
double V = Math.Atan2(head_direction.Y, head_direction.X);
if (turning == TurnDirection.Left)
V -= gameTime.ElapsedGameTime.Ticks * Settings.Worm.turnspeed;
else if (turning == TurnDirection.Right)
V += gameTime.ElapsedGameTime.Ticks * Settings.Worm.turnspeed;
setDirection(V);
turning = TurnDirection.None;
}
//New position
head_position.X += head_direction.X * Settings.Worm.movespeed * gameTime.ElapsedGameTime.Ticks;
head_position.Y += head_direction.Y * Settings.Worm.movespeed * gameTime.ElapsedGameTime.Ticks;
if (!making_hole && Settings.Worm.point_resolution < (gameTime.TotalGameTime.Ticks - last_point_time))
{
AddPoint(CurrentVector());
last_point_time = gameTime.TotalGameTime.Ticks;
}
}
}
//assigns XdistanceFromPLayer with the absolute distance from player,
//also creates the angle, speed, and turn direction
//also sets curveInt to 0
void AssignCircle()
{
curveInt = 0;
XDistanceFromPlayer = Player.transform.position.x - transform.position.x;
if (XDistanceFromPlayer < 0)
{
XDistanceFromPlayer *= -1;
}
CurveAngle = 180 / CurveCount;
CurveSpeed = ((XDistanceFromPlayer * 3.14f) / 2f) / CurveCount;
if (transform.position.x < Player.transform.position.x)
{
turn = TurnDirection.right;
}
else if (transform.position.x > Player.transform.position.x)
{
turn = TurnDirection.left;
}
}
/// <summary>
/// Creates a new instance of the <see cref="TurnCommand"/> class
/// </summary>
/// <param name="turnDirection">The direction the robot is instructed to turn</param>
public TurnCommand(TurnDirection turnDirection)
{
TurnDirection = turnDirection;
}
/// <summary>
/// Turnning one step in specifies direction.
/// </summary>
/// <param name="direction">The turnning direction.</param>
/// <remarks>You can call this function only
/// the <see cref="AutoTurn"/> is set to <c>false</c>.</remarks>
public void TrunOnStep(TurnDirection direction)
{
if (AutoTurn)
return;
if (CarouselCanvas != null)
{
double perAngle = _2PI / CarouselCanvas.Children.Count;
foreach (var item in CarouselCanvas.Children)
{
CarouselItem cItem = item as CarouselItem;
if (cItem != null)
{
if (direction == TurnDirection.Clockwise)
{
cItem.Angle += perAngle;
}
else
{
cItem.Angle -= perAngle;
}
// if overceed 2 PI, then adjust it
if (cItem.Angle > _2PI)
{
cItem.Angle -= _2PI;
}
else if (cItem.Angle < -_2PI)
{
cItem.Angle += _2PI;
}
}
}
}
}
private void Turn(TurnDirection direction)
{
CurrentPosition.SetOrientation(direction);
}
// Update is called once per frame
void Update()
{
elapsedTime += Time.deltaTime;
if (!ScoreManager.inst.GameOver)
{
forwardSpeed += elapsedTime * 0.005f;
}
Vector3 deltaMove = transform.forward * forwardSpeed;
Vector3 lateralMove = Vector3.zero;
switch (state)
{
case State.Default:
{
float horizontal = Input.GetAxisRaw("Horizontal");
Vector3 toCenter = Vector3.Project(transform.position - railOrigin.position, railOrigin.right);
// go back to origin if not holding down any keys
if (horizontal == 0f)
{
lateralMove = -toCenter; // new Vector3(-transform.localPosition.x, 0.0f, 0.0f);
}
else
{
// clamp position
if (toCenter.magnitude < lateralRange)
{
lateralMove = transform.right * horizontal;
}
}
}
break;
case State.Turning:
// move according to target forward
deltaMove = railOrigin.forward * forwardSpeed;
float angle = turnsPerSecond * targetAngle * Time.deltaTime;
if (Mathf.Abs(degreesTurned + angle) >= 90f)
{
// rotate the leftover amount and exit
angle = targetAngle - degreesTurned;
degreesTurned = 0f;
if (ScoreManager.inst.GameOver)
{
state = State.GameOver;
}
else
{
state = State.Default;
}
}
else
{
// rotate full amount
degreesTurned += angle;
}
transform.Rotate(Vector3.up, angle);
break;
case State.OnTrigger:
{
// keep moving towards center
Vector3 toCenter = Vector3.Project(transform.position - railOrigin.position, railOrigin.right);
lateralMove = -toCenter;
TurnDirection direction = TurnDirection.None;
if (Input.GetKeyDown(KeyCode.A))
{
direction = TurnDirection.Left;
}
else if (Input.GetKeyDown(KeyCode.D))
{
direction = TurnDirection.Right;
}
if (direction != TurnDirection.None)
{
bool success = Turn(intersectingRouter, direction);
state = State.Turning;
if (success)
{
ScoreManager.inst.PlayerScored();
}
else
{
ScoreManager.inst.FailedTurn();
}
}
}
break;
case State.TriggerExit:
{
TurnDirection direction = TurnDirection.Straight;
bool success = Turn(intersectingRouter, direction);
state = State.Default;
if (success)
{
ScoreManager.inst.PlayerScored();
}
else
{
ScoreManager.inst.FailedTurn();
}
}
break;
case State.GameOver:
{
}
break;
default:
break;
}
deltaMove += lateralMove * lateralSpeed;
controller.Move(deltaMove * Time.deltaTime);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="initialLane"></param>
/// <param name="finalLane"></param>
/// <param name="interconnect"></param>
public TurnState(LaneID initialLane, LaneID finalLane, InterconnectID interconnect, TurnDirection turnDirection)
: base(initialLane, finalLane, interconnect)
{
this.TurnDirection = turnDirection;
}
public RobotUTurnAction(TurnDirection direction, TurnDirection?initialLookDirection = null)
{
m_turnDirection = direction;
m_initialLookDirection = initialLookDirection;
}
public virtual bool Turn(TurnDirection direction)
{
return(true);
}
public override void Turn(TurnDirection direction)
{
}
public Dictionary<CommandFields, short> Update(Robot robot, Stopwatch stopwatch)
{
Dictionary<CommandFields, short> outputState = new Dictionary<CommandFields, short>();
// Check for start pulse
if (!started)
{
// Set flag
started = true;
// Record start time
startTime = stopwatch.ElapsedMilliseconds;
// Set state
state = AlgorithmState.LiftingBin;
}
switch (state)
{
case AlgorithmState.FinePositioning:
// Read proximity sensors
outputState[Comms.CommandEncoding.CommandFields.LeftBucketActuator] = 0;
outputState[Comms.CommandEncoding.CommandFields.RightBucketActuator] = 0;
// Calcualte error
double error = robot.TelemetryFeedback.RearProximityRight - robot.TelemetryFeedback.RearProximityLeft;
// Check for position converged
if ((robot.TelemetryFeedback.RearProximityLeft - robot.TelemetryFeedback.RearProximityRight) < 10)
state = AlgorithmState.LiftingBin;
break;
case AlgorithmState.LiftingBin:
// Set state
outputState[Comms.CommandEncoding.CommandFields.TranslationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.RotationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.LeftBucketActuator] = 1000;
outputState[Comms.CommandEncoding.CommandFields.RightBucketActuator] = 1000;
// Check for bin fully raised
if (robot.TelemetryFeedback.BinUpperSwitchDepressed)
{
state = AlgorithmState.WiggleRotational;
// Store start time
startTime = stopwatch.ElapsedMilliseconds;
}
break;
case AlgorithmState.WiggleRotational:
// Calculate time
long elapsedTime = stopwatch.ElapsedMilliseconds - startTime;
if (elapsedTime > 1500)
{
// Change direction
if (turnDirection == TurnDirection.Left)
turnDirection = TurnDirection.Right;
else
turnDirection = TurnDirection.Left;
// Increment counter
turnCount++;
// Reset start timer
startTime = stopwatch.ElapsedMilliseconds;
}
// Check convergence of MCL
if (turnCount > 3)
{
Console.WriteLine("Done wiggling");
// Set flag
state = AlgorithmState.LoweringBin;
// Set state
outputState[Comms.CommandEncoding.CommandFields.TranslationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.RotationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.LeftBucketActuator] = 0;
outputState[Comms.CommandEncoding.CommandFields.RightBucketActuator] = 0;
}
else
{
// Set static state
outputState[Comms.CommandEncoding.CommandFields.TranslationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.RotationalVelocity] = (short)turnDirection;
outputState[Comms.CommandEncoding.CommandFields.LeftBucketActuator] = 0;
outputState[Comms.CommandEncoding.CommandFields.RightBucketActuator] = 0;
}
break;
case AlgorithmState.LoweringBin:
Console.WriteLine("Lowering bin");
outputState[Comms.CommandEncoding.CommandFields.TranslationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.RotationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.LeftBucketActuator] = -1000;
outputState[Comms.CommandEncoding.CommandFields.RightBucketActuator] = -1000;
// Check for bin fully raised
if (robot.TelemetryFeedback.BinLowerSwitchDepressed)
state = AlgorithmState.Done;
break;
case AlgorithmState.Done:
Console.WriteLine("Done");
// Set state
outputState[Comms.CommandEncoding.CommandFields.TranslationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.RotationalVelocity] = 0;
outputState[Comms.CommandEncoding.CommandFields.LeftBucketActuator] = 0;
outputState[Comms.CommandEncoding.CommandFields.RightBucketActuator] = 0;
break;
default:
break;
}
// Static outputs
outputState[Comms.CommandEncoding.CommandFields.BucketPivot] = 0;
outputState[Comms.CommandEncoding.CommandFields.BucketPitch] = 0;
outputState[Comms.CommandEncoding.CommandFields.RangeFinderServo] = 90;
return outputState;
}
private string TurnResult(TurnDirection turnDirection)
{
return($"Turned {turnDirection.ToString().ToLower()} towards {CurrentOrientation.ToString()}");
}
// The turnning direction changed
private void TurnDirectionChanged(TurnDirection direction)
{
if (CarouselCanvas != null)
{
Storyboard sb = BuildStoryboard(CarouselCanvas.Children, direction);
if (AutoTurn)
sb.Begin();
}
}
public SpecialTrackPiece(Point location, TurnDirection direction)
{
this.location = location;
this.type = Types.TURN;
this.direction = direction;
}
// Use this for initialization
void Start()
{
Application.targetFrameRate = 60;
for (int i = 0; i < boxesToDestroy.Length; i++)
{
boxesToDestroy[i] = null;
}
rateShort = 1.0f / 3;
rateMedium = 1.0f / 3;
nextTurnDirection = TurnDirection.LEFT;
for (int i = 0; i < 3; i++)
{
GenerateNextBox(false);
}
txtScore.text = score.ToString();
best = PlayerPrefs.GetInt("best", 0);
if (lastBest == -1)
{
lastBest = best;
}
if (best == 0)
{
txtBest.gameObject.SetActive(false);
}
else
{
if (best != lastBest)
{
iTween.ValueTo(gameObject, iTween.Hash("from", lastBest, "to", best, "time", 0.5f, "onupdate", "UpdateBest"));
float bigScale = 1.5f;
float time = 0.5f;
iTween.ScaleTo(txtBest.gameObject, iTween.Hash("scale", new Vector3(bigScale, bigScale, 1), "easetype", "easeInOutSine", "time", time));
iTween.ScaleTo(txtBest.gameObject, iTween.Hash("scale", new Vector3(1, 1, 1), "easetype", "easeInOutSine", "time", time, "delay", time));
}
else
{
txtBest.text = "BEST " + best.ToString();
}
txtBest.gameObject.SetActive(true);
}
lastBest = best;
/*
* currentColor = new Color(84 / 255.0f, 140 / 255.0f, 215 / 255.0f, 1);
*
* // color correction
* Vector3 hcy = SCR_ColorConverter.RGBToHCY(new Vector3(currentColor.r, currentColor.g, currentColor.b));
* hcy.y = 1;
* hcy.z += 0.075f;
* Vector3 rgb = SCR_ColorConverter.HCYToRGB(hcy);
* currentColor = new Color(rgb.x, rgb.y, rgb.z, 1);
*/
colorIndex = Random.Range(0, MAT_BOXES.Length);
currentColor = MAT_BOXES[colorIndex].color;
GenerateNextColor();
matBox.color = currentColor;
matCylinder.color = currentColor;
iTween.ValueTo(gameObject, iTween.Hash("from", 0, "to", 1, "time", 1f, "easetype", "easeInOutSine", "onupdate", "UpdateTapToPlay", "looptype", "pingPong", "ignoretimescale", true));
txtTapToPlay.gameObject.SetActive(true);
scrCamera = Camera.main.GetComponent <SCR_Camera>();
if (numberGems > lastNumberGems)
{
iTween.ValueTo(gameObject, iTween.Hash("from", lastNumberGems, "to", numberGems, "time", 0.5f, "onupdate", "UpdateGems", "ignoretimescale", true));
float bigScale = 1.5f;
float time = 0.5f;
iTween.ScaleTo(gemNumber, iTween.Hash("scale", new Vector3(bigScale, bigScale, 1), "easetype", "easeInOutSine", "time", time, "ignoretimescale", true));
iTween.ScaleTo(gemNumber, iTween.Hash("scale", new Vector3(1, 1, 1), "easetype", "easeInOutSine", "time", time, "delay", time, "ignoretimescale", true));
iTween.ScaleTo(gemImage, iTween.Hash("scale", new Vector3(bigScale, bigScale, 1), "easetype", "easeInOutSine", "time", time, "ignoretimescale", true));
iTween.ScaleTo(gemImage, iTween.Hash("scale", new Vector3(1, 1, 1), "easetype", "easeInOutSine", "time", time, "delay", time, "ignoretimescale", true));
}
else
{
gemNumber.GetComponent <Text>().text = numberGems.ToString();
}
lastNumberGems = numberGems;
Time.timeScale = speedMin;
state = State.READY;
#if UNITY_ANDROID
string appId = "ca-app-pub-0081066185741622~3790493478";
#elif UNITY_IPHONE
string appId = "ca-app-pub-0081066185741622~1392680402";
#else
string appId = "unexpected_platform";
#endif
// Initialize the Google Mobile Ads SDK.
MobileAds.Initialize(appId);
RequestInterstitial();
}
public void TurnMower(int gardenLength, int gardenWidth, int startX, int startY, Orientation orientation, TurnDirection turnDirection, Orientation expectedOrientation)
{
var context = new MoveMowerTestContext();
Position currentPosition = new Position(new Coordinates(startX, startY), orientation);
"Given I have a garden"
.x(() => context.Garden = new Garden(gardenLength, gardenWidth));
"And I have started a new Mower inside the garden"
.x(() => context.Mower = this.CreateNewMower(context.Garden, startX, startY, orientation));
"When I turn the Mower"
.x(() => context.Mower.Turn(turnDirection));
"Then its orientation should be as expected"
.x(() => context.Mower.GetPosition().Orientation.Should().Be(expectedOrientation));
}
public void Turn(TurnDirection turn)
{
turning = turn;
}
public Turn()
{
players = new List <Player>();
currentPlayerIndex = 0;
turnDirection = TurnDirection.Ascending;
}
public Gear(Board board, Tile baseTile, TurnDirection direction, int x, int y) : base(board, baseTile, x, y)
{
Turn = direction;
}
public TurntableTileBehaviour(Tile tile, KeyValuePairs kvp) : base(tile, kvp)
{
TurnDirection = kvp.GetEnum("turn_direction", TurnDirection.Left);
Animation = kvp.GetString("animation", null);
Sound = kvp.GetString("sound", null);
}
public Gear(Board board, Tile baseTile, TurnDirection direction, int x, int y)
: base(board, baseTile, x, y)
{
Turn = direction;
}
protected static TurnDirection GetTurnDirection(Robot robot, TileCoordinates position, FlatDirection direction, TurnDirection preference, out bool o_uTurn, bool ignoreMovingObjects)
{
var left = direction.RotateLeft();
var right = direction.RotateRight();
bool canGoLeft = CanEnter(robot, position.Move(left), left, ignoreMovingObjects);
bool canGoRight = CanEnter(robot, position.Move(right), right, ignoreMovingObjects);
if (canGoRight && !canGoLeft)
{
o_uTurn = false;
return(TurnDirection.Right);
}
else if (canGoLeft && !canGoRight)
{
o_uTurn = false;
return(TurnDirection.Left);
}
else
{
o_uTurn = (!canGoLeft && !canGoRight);
return(preference);
}
}
public LowRiskLocalization(AutonomyConfiguration configuration)
{
this.configuration = configuration;
this.turnDirection = TurnDirection.Right;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="initial"></param>
/// <param name="final"></param>
/// <param name="interconnect"></param>
/// <param name="turnDirection"></param>
public WaitingAtStopState(LaneID initial, LaneID final, InterconnectID interconnect, TurnDirection turnDirection)
: base(initial, final, interconnect)
{
this.TurnDirection = turnDirection;
}
public TurnCommand(Toy toy, TurnDirection turnDirection)
: base(toy)
{
this._toy.TurnToDirection = turnDirection;
}
public void Turn(TurnDirection direction, double angle = 5)
{
Movement?.Turn(Character, direction, angle);
}
public Deposition(AutonomyConfiguration configuration)
{
// Assign fields
this.configuration = configuration;
this.turnDirection = TurnDirection.Right;
}
public async Task TurnByKeyPress(List <MovableCharacter> charactersToTurn, Key key)
{
TurnDirection turnDirection = GetDirectionFromKey(key);
await Turn(charactersToTurn, turnDirection);
}
public void TurnWheel(TurnDirection direction)
{
switch(direction)
{
case TurnDirection.Left:
break;
case TurnDirection.Right:
break;
case TurnDirection.Center:
break;
default:
break;
}
}
public ulong DetermineDurationOfTurn(Angle start, Angle end, Angle turnRate, TurnDirection turnDirection)
{
if (turnDirection == TurnDirection.Clockwise)
{
if (end > start)
{
end = new Angle(end.Value - (Math.PI * 2));
}
}
if (turnDirection == TurnDirection.AntiClockwise)
{
if (end < start)
{
end = new Angle(end.Value + (Math.PI * 2));
}
}
var turnAngle = start - end;
var stuff = (turnAngle.Value / turnRate.Value) * -1000.0;
return (ulong)(Math.Round(stuff));
}
/// <summary>
/// Create the total storyboard contains all item's animations.
/// </summary>
/// <param name="items">The carousel items collection.</param>
/// <param name="direction">The carousel turnning direction.</param>
/// <returns>The storyboard just created.</returns>
private Storyboard BuildStoryboard(UIElementCollection items, TurnDirection direction)
{
// The carousel storyboard
Storyboard sb = null;
if (this.Resources.Contains(CarouselStoryboardKey))
{
// if already in resources, get from resources
sb = this.Resources[CarouselStoryboardKey] as Storyboard;
// Must stop it before we change it
sb.Stop();
// and clear the children
sb.Children.Clear(); // because we rebuild all item
}
else
{
sb = new Storyboard();
// Add to resources dictionary
this.Resources.Add(CarouselStoryboardKey, sb);
}
// Now, we start build each item's storyboard
int itemsCount = items.Count;
double perAngle=_2PI / itemsCount;
double by = _2PI;
for (int i = 0; i < itemsCount; i++)
{
double angle = i * perAngle + Math.PI / 2;
// We only care the carouselitem
CarouselItem item = items[i] as CarouselItem;
if (item != null)
{
item.Angle = angle;
// Add item's storyboard to main storyboard
if (direction == TurnDirection.Clockwise)
{
sb.Children.Add(BuildStoryboard(item, by, Duration));
}
else
{
sb.Children.Add(BuildStoryboard(item, -by, Duration));
}
}
}
return sb;
}
public Angle DetermineTurnRate(double speed, double radius, TurnDirection turnDirection)
{
var turnTime = (Math.PI * radius) / speed;
double turnRate = Math.PI / turnTime;
if (turnDirection == TurnDirection.Clockwise)
{
turnRate = -turnRate;
}
return new Angle(turnRate);
}
public async Task Turn(MovableCharacter characterToTurn, TurnDirection direction, double angle = 5)
{
await Turn(new List <MovableCharacter> {
characterToTurn
}, direction, angle);
}
private void ChangeDirection(char c)
{
switch (c)
{
case '\\':
switch (this.movingDirection)
{
case Direction.LEFT:
movingDirection = Direction.UP;
break;
case Direction.RIGHT:
movingDirection = Direction.DOWN;
break;
case Direction.UP:
movingDirection = Direction.LEFT;
break;
case Direction.DOWN:
movingDirection = Direction.RIGHT;
break;
}
break;
case '/':
switch (this.movingDirection)
{
case Direction.LEFT:
movingDirection = Direction.DOWN;
break;
case Direction.RIGHT:
movingDirection = Direction.UP;
break;
case Direction.UP:
movingDirection = Direction.RIGHT;
break;
case Direction.DOWN:
movingDirection = Direction.LEFT;
break;
}
break;
case '+':
switch (nextTurn)
{
case TurnDirection.LEFT:
movingDirection = (Direction)mod(((int)movingDirection - 1), 4);
if ((int)movingDirection == -1)
{
Console.Write("?");
}
break;
case TurnDirection.RIGHT:
movingDirection = (Direction)mod(((int)movingDirection + 1), 4);
break;
default:
break;
}
nextTurn = (TurnDirection)((int)(nextTurn + 1) % 3);
break;
}
UpdateVelocity();
}
/// <summary>
///
/// </summary>
/// <param name="destination">The position of the destination relative to the turning point</param>
/// <param name="radius">The radius of the turning circle</param>
/// <param name="turnDirection">If the turn is clockwise or anti clockwise</param>
/// <returns></returns>
public Angle DetermineTurnEnd(Vector destination, double radius, TurnDirection turnDirection)
{
Angle angleTowardsDestination = new Angle(destination);
Angle tangentAngles = new Angle(Math.Acos(radius / destination.Length));
Angle desiredEndPoint;
if (turnDirection == TurnDirection.Clockwise)
{
desiredEndPoint = angleTowardsDestination + tangentAngles;
}
else
{
desiredEndPoint = angleTowardsDestination - tangentAngles;
}
desiredEndPoint.ReduceAngle();
return desiredEndPoint;
}
public void Turn(TurnDirection turn)
{
switch (turn)
{
case TurnDirection.Left:
Direction = TileDirectionUtil.TurnLeft(Direction);
break;
case TurnDirection.Right:
Direction = TileDirectionUtil.TurnRight(Direction);
break;
}
}
public Robot(TileCoordinates position, FlatDirection direction, string colour, bool immobile, bool required, RobotAction initialAction, Vector3 guiColour, TurnDirection turnPreference, Model model, AnimSet animations, SoundSet sounds, Vector3?lightColour, float?lightRadius, RenderPass renderPass, bool castShadows)
{
m_colour = colour;
m_immobile = immobile;
m_required = required;
m_spawnAction = initialAction;
m_spawnPosition = position;
m_spawnDirection = direction;
m_turnPreference = turnPreference;
if (lightColour.HasValue && lightRadius.HasValue)
{
m_lightColour = lightColour.Value;
m_light = new PointLight(Vector3.Zero, lightColour.Value, lightRadius.Value);
}
m_modelInstance = new ModelInstance(model, Matrix4.Identity);
m_animations = animations;
m_sounds = sounds;
m_guiColour = guiColour;
m_renderPass = renderPass;
m_castShadows = castShadows;
}
public void GenerateNextBox(bool fade = true)
{
count++;
Transform next = null;
float width = 1;
float length = 1;
if (count < nextCount)
{
next = Instantiate(PFB_BOX);
if (lastBox.tag == "Box")
{
width = 1;
float r = Random.Range(0f, 1f);
if (r < rateShort)
{
length = 1.5f;
next.GetComponent <SCR_Box>().SetLength(BoxLength.SHORT);
}
else if (r < rateShort + rateMedium)
{
length = 2.5f;
next.GetComponent <SCR_Box>().SetLength(BoxLength.MEDIUM);
}
else
{
length = 3.5f;
next.GetComponent <SCR_Box>().SetLength(BoxLength.LONG);
}
key++;
float shortRange = 0.666f;
float shortMin = 0.333f;
float shortAccelRev = 10.0f;
rateShort = (key * shortRange) / (key + shortAccelRev) + shortMin;
/*
* float mediumRange = 0.166f;
* float mediumMin = 0.333f;
* float mediumAccelRev = 50.0f;
* rateMedium = (key * mediumRange) / (key + mediumAccelRev) + mediumMin;
*/
Time.timeScale = (key * speedRange) / (key + speedAccelRev) + speedMin;
}
if (lastBox.tag == "Corner")
{
width = 1;
length = 2.2f;
next.GetComponent <SCR_Box>().SetLength(BoxLength.MEDIUM);
}
}
else
{
next = Instantiate(PFB_CORNER);
/*
* float r = Random.Range(0f, 1f);
* if (r < 0.5f) {
* next.GetComponent<SCR_Corner>().turnDirection = TurnDirection.LEFT;
* }
* else {
* next.GetComponent<SCR_Corner>().turnDirection = TurnDirection.RIGHT;
* }
*/
next.GetComponent <SCR_Corner>().turnDirection = nextTurnDirection;
if (nextTurnDirection == TurnDirection.LEFT)
{
nextTurnDirection = TurnDirection.RIGHT;
}
else
{
nextTurnDirection = TurnDirection.LEFT;
}
width = 1;
length = 2.2f;
next.GetComponent <SCR_Box>().SetLength(BoxLength.MEDIUM);
count = 0;
float r = Random.Range(0f, 1f);
if (r < 0.3f)
{
nextCount = 2;
}
else
{
nextCount = Random.Range(3, 7);
}
}
float x = lastBox.position.x;
float y = lastBox.position.y;
float z = lastBox.position.z;
SCR_Box scrBoxLast = lastBox.GetComponent <SCR_Box>();
SCR_Box scrBoxNext = next.GetComponent <SCR_Box>();
if (lastBox.tag == "Box")
{
WallDirection wallDirection = scrBoxLast.wallDirection;
if (wallDirection == WallDirection.NONE)
{
wallDirection = savedWallDirection;
}
if (wallDirection == WallDirection.NEGATIVE_X)
{
next.localScale = new Vector3(length, PFB_BOX.localScale.y, width);
x += lastBox.localScale.x * 0.5f + next.localScale.x * 0.5f;
y += PFB_BOX.localScale.y;
}
if (wallDirection == WallDirection.POSITIVE_X)
{
next.localScale = new Vector3(length, PFB_BOX.localScale.y, width);
x -= lastBox.localScale.x * 0.5f + next.localScale.x * 0.5f;
y += PFB_BOX.localScale.y;
}
if (wallDirection == WallDirection.NEGATIVE_Z)
{
next.localScale = new Vector3(width, PFB_BOX.localScale.y, length);
y += PFB_BOX.localScale.y;
z += lastBox.localScale.z * 0.5f + next.localScale.z * 0.5f;
}
if (wallDirection == WallDirection.POSITIVE_Z)
{
next.localScale = new Vector3(width, PFB_BOX.localScale.y, length);
y += PFB_BOX.localScale.y;
z -= lastBox.localScale.z * 0.5f + next.localScale.z * 0.5f;
}
scrBoxNext.wallDirection = wallDirection;
}
if (lastBox.tag == "Corner")
{
SCR_Corner scrCorner = lastBox.GetComponent <SCR_Corner>();
scrBoxNext.wallDirection = WallDirection.NONE;
Transform cylinder = Instantiate(PFB_CYLINDER);
scrBoxNext.cylinder = cylinder;
if (scrBoxLast.wallDirection == WallDirection.NEGATIVE_X)
{
next.localScale = new Vector3(width, PFB_BOX.localScale.y, length);
x += lastBox.localScale.x * 0.5f;
if (scrCorner.turnDirection == TurnDirection.LEFT)
{
z += next.localScale.z * 0.5f;
savedWallDirection = WallDirection.NEGATIVE_Z;
}
if (scrCorner.turnDirection == TurnDirection.RIGHT)
{
z -= next.localScale.z * 0.5f;
savedWallDirection = WallDirection.POSITIVE_Z;
}
cylinder.position = new Vector3(lastBox.position.x + lastBox.localScale.x * 0.5f, lastBox.position.y, lastBox.position.z);
}
if (scrBoxLast.wallDirection == WallDirection.POSITIVE_X)
{
next.localScale = new Vector3(width, PFB_BOX.localScale.y, length);
x -= lastBox.localScale.x * 0.5f;
if (scrCorner.turnDirection == TurnDirection.LEFT)
{
z -= next.localScale.z * 0.5f;
savedWallDirection = WallDirection.POSITIVE_Z;
}
if (scrCorner.turnDirection == TurnDirection.RIGHT)
{
z += next.localScale.z * 0.5f;
savedWallDirection = WallDirection.NEGATIVE_Z;
}
cylinder.position = new Vector3(lastBox.position.x - lastBox.localScale.x * 0.5f, lastBox.position.y, lastBox.position.z);
}
if (scrBoxLast.wallDirection == WallDirection.NEGATIVE_Z)
{
next.localScale = new Vector3(length, PFB_BOX.localScale.y, width);
z += lastBox.localScale.z * 0.5f;
if (scrCorner.turnDirection == TurnDirection.LEFT)
{
x -= next.localScale.x * 0.5f;
savedWallDirection = WallDirection.POSITIVE_X;
}
if (scrCorner.turnDirection == TurnDirection.RIGHT)
{
x += next.localScale.x * 0.5f;
savedWallDirection = WallDirection.NEGATIVE_X;
}
cylinder.position = new Vector3(lastBox.position.x, lastBox.position.y, lastBox.position.z + lastBox.localScale.z * 0.5f);
}
if (scrBoxLast.wallDirection == WallDirection.POSITIVE_Z)
{
next.localScale = new Vector3(length, PFB_BOX.localScale.y, width);
z -= lastBox.localScale.z * 0.5f;
if (scrCorner.turnDirection == TurnDirection.LEFT)
{
x += next.localScale.x * 0.5f;
savedWallDirection = WallDirection.NEGATIVE_X;
}
if (scrCorner.turnDirection == TurnDirection.RIGHT)
{
x -= next.localScale.x * 0.5f;
savedWallDirection = WallDirection.POSITIVE_X;
}
cylinder.position = new Vector3(lastBox.position.x, lastBox.position.y, lastBox.position.z - lastBox.localScale.z * 0.5f);
}
}
next.position = new Vector3(x, y, z);
//if (fade) {
//iTween.FadeFrom(next.gameObject, iTween.Hash("alpha", 0, "time", 0.5f));
//}
scrBoxNext.GenerateGem();
lastBox = next;
}
