private void Register(IRotatable obj, ICollection <IRotatable> list)
{
if (obj != null && !list.Contains(obj))
{
list.Add(obj);
}
}
public RotationInterpolator(IRotatable target, float start, float end, EaseTypes easeType,
float duration = 0, bool isRepeatable = true) : base(start, end, duration, easeType, isRepeatable)
{
Debug.Assert(target != null, NullMessage);
this.target = target;
}
private static void RotateLeftLayer <T>(DataCube <T> cube, int left)
{
int max = cube.Size - 1;
for (int i = 0; i < cube.Size / 2; i++)
{
for (int j = i; j < max - i; j++)
{
T temp = cube[left, i, j];
cube[left, i, j] = cube[left, max - j, i];
cube[left, max - j, i] = cube[left, max - i, max - j];
cube[left, max - i, max - j] = cube[left, j, max - i];
cube[left, j, max - i] = temp;
}
}
for (int i = 0; i < cube.Size; i++)
{
for (int j = 0; j < cube.Size; j++)
{
IRotatable rotatable = cube[left, i, j] as IRotatable;
if (rotatable != null)
{
rotatable.RotateAroundLeft();
}
}
}
}
public void OrientationTest()
{
IRotatable rotatable = ((IRotatable)driver);
rotatable.Orientation = ScreenOrientation.Landscape;
Assert.AreEqual(ScreenOrientation.Landscape, rotatable.Orientation);
}
private static void RotateTopLayer <T>(DataCube <T> cube, int top)
{
if (top < 0 || top > cube.Size)
{
throw new ArgumentOutOfRangeException("top");
}
int max = cube.Size - 1;
for (int i = 0; i < cube.Size / 2; i++)
{
for (int j = i; j < max - i; j++)
{
T temp = cube[j, top, i];
cube[j, top, i] = cube[i, top, max - j];
cube[i, top, max - j] = cube[max - j, top, max - i];
cube[max - j, top, max - i] = cube[max - i, top, j];
cube[max - i, top, j] = temp;
}
}
for (int i = 0; i < cube.Size; i++)
{
for (int j = 0; j < cube.Size; j++)
{
IRotatable rotatable = cube[i, top, j] as IRotatable;
if (rotatable != null)
{
rotatable.RotateAroundTop();
}
}
}
}
public void OrientationTest()
{
IRotatable rotatable = ((IRotatable)driver);
rotatable.Orientation = ScreenOrientation.Portrait;
Assert.AreEqual(ScreenOrientation.Portrait, rotatable.Orientation);
}
private static void RotateDepthLayer <T>(DataCube <T> cube, int depth)
{
if (depth < 0 || depth > cube.Size)
{
throw new ArgumentOutOfRangeException("depth");
}
int max = cube.Size - 1;
for (int i = 0; i < cube.Size / 2; i++)
{
for (int j = i; j < max - i; j++)
{
T temp = cube[i, j, depth];
cube[i, j, depth] = cube[max - j, i, depth];
cube[max - j, i, depth] = cube[max - i, max - j, depth];
cube[max - i, max - j, depth] = cube[j, max - i, depth];
cube[j, max - i, depth] = temp;
}
}
for (int i = 0; i < cube.Size; i++)
{
for (int j = 0; j < cube.Size; j++)
{
IRotatable rotatable = cube[i, j, depth] as IRotatable;
if (rotatable != null)
{
rotatable.RotateAroundDepth();
}
}
}
}
public void Construct(IMovable movement, IRotatable rotatable, IWave wave, IKillable killable)
{
this.killable = killable;
this.movement = movement;
this.rotatable = rotatable;
this.wave = wave;
}
public GateSpawner(IRotatable player, GateSettings settings)
{
_numInColumn = settings.NumInColumn;
_gateBlock = settings.GateBlock;
_outerGate = settings.OuterGate;
_player = player;
}
/// <summary>
/// Sets the orientation of the browser.
/// </summary>
/// <returns>This command always returns <see langword="null"/>.</returns>
public override object Execute()
{
IRotatable rotatableDriver = Session.Driver as IRotatable;
rotatableDriver.Orientation = this.orientation;
return(null);
}
private void UpdateActiveObjectStatus(object xiObject)
{
string lStatus = "";
Chunk lChunk = xiObject as Chunk;
if (lChunk != null)
{
lStatus += lChunk.Name + " - ";
}
IPositionable lPos = xiObject as IPositionable;
if (lPos != null)
{
lStatus += string.Format(" Pos: ({0},{1},{2})",
lPos.OriginPosition.X,
lPos.OriginPosition.Y,
lPos.OriginPosition.Z);
}
IRotatable lRot = xiObject as IRotatable;
if (lRot != null)
{
lStatus += string.Format(" Rot: ({0},{1},{2})",
lRot.RotationVector.X,
lRot.RotationVector.Y,
lRot.RotationVector.Z);
}
mMainForm.ThreeDeeEditorStatusLabel.Text = lStatus;
}
private void Rotate(bool right, IRotatable rot)
{
Direction newDir;
Direction facing = rot.GetFacing();
switch (facing)
{
case (Direction.NORTH):
newDir = right ? Direction.EAST : Direction.WEST;
break;
case (Direction.EAST):
newDir = right ? Direction.SOUTH : Direction.NORTH;
break;
case (Direction.SOUTH):
newDir = right ? Direction.WEST : Direction.EAST;
break;
case (Direction.WEST):
newDir = right ? Direction.NORTH : Direction.SOUTH;
break;
default:
newDir = facing;
break;
}
rot.SetDirection(newDir);
}
// we need to remove blocks which makes impossible for player to traverse through gate.
//We make them all prepared after first creation in Gate class
private void OnTriggerEnter(Collider other)
{
if (!IsPrepared)
{
IRotatable player = other.GetComponentInParent <IRotatable>();
if (player == null)
{
return;
}
IsPrepared = true;
Disable();
}
else
{
ISpeedable playerSpeed = other.GetComponentInParent <ISpeedable>();
if (playerSpeed == null)
{
return;
}
_isMoved = true;
_startPos = transform.position;
playerSpeed.SlowDown();
_rb.isKinematic = false;
_rb.AddForce(Vector3.right, ForceMode.Impulse);
}
}
public void Draw(SpriteBatch spriteBatch, IRotatable rotatingObject)
{
// Only draw the animation when we are active
if (this.Active)
{
spriteBatch.Draw(this.spriteStrip, this.destinationRect, this.sourceRect, Color.White, rotatingObject.Rotation, new Vector2(this.FrameWidth / 2, this.FrameHeight / 2), SpriteEffects.None, 0f);
}
}
private void Awake()
{
rotator = GetComponent <IRotatable> ();
shooting = GetComponent <IShooting> ();
magazineManager = GetComponent <IWeaponMagazineManager> ();
magazineManager.Initialize(stats);
shooting.Initialize(stats);
}
void Awake()
{
// Initialize references between objects
tankCtrl = GetComponent <IMovable <sbyte> > ();
turretCtrl = GetComponent <IRotatable> ();
weaponCtrl = GetComponent <IShootable> ();
//NetworkServer.Spawn (tankCtrl.gameObject);
}
public void HandleEvent(IRotatable sender, RotateEventArgs e)
{
if (sender == null || e == null)
{
return;
}
if (e.Direction != LastDirection)
{
DirectionChanged = true;
LastDirection = e.Direction;
}
else
{
DirectionChanged = false;
}
if (e.Direction == RotatingDirections.None)
{
return;
}
if (sender is Polyomino)
{
Polyomino polyomino = sender as Polyomino;
if (DirectionChanged)
{
foreach (Mino mino in polyomino.Minoes)
{
Vector2 vector = mino.Position - polyomino.OriginMino.Position;
float r = 0;
switch (e.Direction)
{
case RotatingDirections.Clockwise:
r = +MathHelper.PiOver2;
break;
case RotatingDirections.Counterclockwise:
r = -MathHelper.PiOver2;
break;
default:
break;
}
var x = MathHelper.Clamp(Convert.ToSingle(vector.X * Math.Cos(r) - vector.Y * Math.Sin(r)), float.MinValue, float.MaxValue);
var y = MathHelper.Clamp(Convert.ToSingle(vector.X * Math.Sin(r) + vector.Y * Math.Cos(r)), float.MinValue, float.MaxValue);
mino.Position = polyomino.OriginMino.Position + new Vector2(x, y);
}
}
}
}
public void Initialize(Viewport viewport, Texture2D texture, Vector2 position, IRotatable shooter)
{
this.Texture = texture;
this.Position = position;
this.viewport = viewport;
this.Rotation = shooter.Rotation;
this.Active = true;
this.Damage = DAMAGE;
this.projectileMoveSpeed = SPEED;
}
static void Main(string[] args)
{
Console.Write("Введите кол-во колес : ");
uint countWheels;
if (!Utils.TryEnterNumberFromConsole(out countWheels))
{
HandleIncorrectEntar();
return;
}
Console.Write("Введите кол-во дверей : ");
uint countDoors;
if (!Utils.TryEnterNumberFromConsole(out countDoors))
{
HandleIncorrectEntar();
return;
}
Car car = new Car((int)countWheels, (int)countDoors, "Запорожец");
foreach (Detail detail in car.Details)
{
IRotatable rotatableDetail = detail as IRotatable;
if (rotatableDetail != null)
{
rotatableDetail.Move();
}
}
Console.Write("Введите номер двери : ");
uint doorNumber;
if (Utils.TryEnterNumberFromConsole(out doorNumber))
{
HandleIncorrectEntar();
return;
}
foreach (Detail detail in car.Details)
{
Door door = detail as Door;
if (door != null && door.Number == doorNumber - 1)
{
door.Open();
break;
}
}
Console.Read();
}
private void Unregister(IRotatable obj, IList <IRotatable> list)
{
if (list == null)
{
return;
}
var index = list.IndexOf(obj);
if (index > -1)
{
list.RemoveAt(index);
}
}
private void PerformDraggingObjectControl()
{
Cursor cursor = GuiManager.Cursor;
if (mObjectGrabbed == null || cursor.WindowOver != null)
{
return;
}
#region Move
if (GuiData.ToolsWindow.MoveButton.IsPressed)
{
PositionedObjectMover.MouseMoveObject(mObjectGrabbed);
}
#endregion
#region Scale
else if (GuiData.ToolsWindow.ScaleButton.IsPressed && mObjectGrabbed is IScalable)
{
cursor.StaticPosition = true;
IScalable asIScalable = mObjectGrabbed as IScalable;
asIScalable.ScaleX *= 1 + cursor.XVelocity / 100.0f;
asIScalable.ScaleY *= 1 + cursor.YVelocity / 100.0f;
}
#endregion
#region Rotate
else if (GuiData.ToolsWindow.RotateButton.IsPressed && mObjectGrabbed is IRotatable)
{
cursor.StaticPosition = true;
IRotatable asiRotatable = mObjectGrabbed as IRotatable;
asiRotatable.RotationZ += cursor.YVelocity * SpriteManager.Camera.Z / 100.0f;
if (mObjectGrabbed.Parent != null)
{
mObjectGrabbed.SetRelativeFromAbsolute();
}
}
#endregion
}
private static async Task PermuteAntiClockwise(IRotatable configuration, ICollection<IRotation> solution)
{
await CommonActions.ApplyAndAddRotation(Rotations.RightClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.UpperClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightAntiClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.UpperClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.Upper2, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightAntiClockwise, solution, configuration).ConfigureAwait(false);
}
// Moving logic
private void DoJump(IRotatable rotatable)
{
// Detect jump direction
Vector3 direction = rotatable.GetDirection().ToVector3(transform);
// Reverse axis direction if model/prefab axis reversed
if (ReverseAxis)
{
direction *= -JumpDistance;
}
else
{
direction *= JumpDistance;
}
AnimateJump(direction);
}
public virtual void UpdateInterface()
{
if (this is IHasHP)
{
Interfacing.PerformInterfaceUpdateHP(graphicsHandle, hasHP.currentHP, hasHP.maxHP);
}
IRotatable rotatable = this as IRotatable;
if (rotatable != null)
{
if (rotatable.CanRotate)
{
Interfacing.PerformInterfaceUpdateRotation(graphicsHandle, dir);
}
}
}
void ThrowFire()
{
if (!throwingFire)
{
Vector3 offset = target.transform.position - rotator.transform.position;
offset.Normalize();
offset = new Vector3(offset.x * posMultiplier, offset.y + posUpper, offset.z * posMultiplier);
currentFire = (GameObject)Instantiate(fire, rotator.position + offset, Quaternion.identity);
currentFire.transform.parent = rotator;
if (currentFire != null)
{
IRotatable bc = currentFire.GetComponent <IRotatable>();
bc.SetRotation(rotator.rotation.eulerAngles.y);
}
}
throwingFire = true;
}
protected virtual void DrawObjectLayers(RendererBase <ToyWorld> renderer, ToyWorld world)
{
var gridView = GridView;
Effect.TileTypesIdxOffsetUniform(0);
GL.BindBuffer(BufferTarget.PixelUnpackBuffer, 0);
// Draw objects
foreach (var objectLayer in world.Atlas.ObjectLayers)
{
foreach (var gameObject in objectLayer.GetGameObjects(new RectangleF(gridView)))
{
if (IgnoredGameObjects.Contains(gameObject) || gameObject.Invisible)
{
continue;
}
// Set up transformation to screen space for the gameObject
Matrix transform = Matrix.Identity;
// Model transform
IRotatable rotatableObject = gameObject as IRotatable;
if (rotatableObject != null)
{
transform *= Matrix.CreateRotationZ(rotatableObject.Rotation);
}
transform *= Matrix.CreateScale(new Vector3(gameObject.Size, objectLayer.Thickness) * 0.5f); // from (-1,1) to (-size,size)/2
// World transform
transform *= Matrix.CreateTranslation(new Vector3(gameObject.Position, objectLayer.SpanIntervalFrom + objectLayer.Thickness / 2));
// View and projection transforms
transform *= Owner.ViewProjectionMatrix;
Effect.ModelViewProjectionUniform(ref transform);
// Setup dynamic data
LocalTileTypesBuffer[0] = (ushort)gameObject.TilesetId;
TileTypesTexure.Update1D(1, dataType: PixelType.UnsignedShort, data: LocalTileTypesBuffer);
Cube.Draw();
}
}
}
public static async Task ApplyAndAddRotation(IRotation rotation, ICollection<IRotation> rotations, IRotatable configuration)
{
if (rotation == null) return;
rotations.Add(rotation);
var cubeRotation = rotation as CubeRotation;
var faceRotation = rotation as FaceRotation;
if (cubeRotation != null)
{
await configuration.RotateCube(cubeRotation).ConfigureAwait(false);
}
if (faceRotation != null)
{
await configuration.Rotate(faceRotation).ConfigureAwait(false);
}
}
public Block(Position[,] block)
{
this.blocks = block;
blockRotation = new BlockRotation();
blockCollision = new BlockCollision();
}
/// <summary>
/// Adds the rotation index by one.
/// </summary>
public static void AddRotationIndex (IRotatable tetrimino) {
try {
tetrimino.RotationIndex++;
} catch (ArgumentException) {
tetrimino.RotationIndex = 0;
}
}
void MainForm_KeyDown(object sender, KeyEventArgs e)
{
if (mActiveSurface == null)
{
return;
}
Camera lCamera = mViews[mActiveSurface].Camera;
if (lCamera.ProjectionMode != eProjectionMode.Orthographic)
{
return;
}
if (Control.ModifierKeys == Keys.Shift)
{
IRotatable lObject = ActiveObject as IRotatable;
if (lObject == null)
{
return;
}
double lDelta;
switch (e.KeyCode)
{
case Keys.Up:
lDelta = 0.1;
break;
case Keys.Down:
lDelta = -0.1;
break;
case Keys.Right:
lDelta = 0.1;
break;
case Keys.Left:
lDelta = -0.1;
break;
default:
return;
}
if (Control.ModifierKeys != Keys.Control)
{
lDelta /= 5;
}
lObject.RotationVector = Utils.RotationMatrixToShort3Coord(
Matrix.Rotation(lDelta, lCamera.ZAxis) * Utils.Short3CoordToRotationMatrix(lObject.RotationVector));
RebuildObject(lObject);
InvalidateAllViewers();
}
else
{
IPositionable lObject = ActiveObject as IPositionable;
if (lObject == null)
{
return;
}
Vector lDelta;
switch (e.KeyCode)
{
case Keys.Up:
lDelta = lCamera.YAxis;
break;
case Keys.Down:
lDelta = -lCamera.YAxis;
break;
case Keys.Right:
lDelta = lCamera.XAxis;
break;
case Keys.Left:
lDelta = -lCamera.XAxis;
break;
default:
return;
}
if (Control.ModifierKeys != Keys.Control)
{
lDelta *= 5;
}
lObject.OriginPosition.X += (short)(lDelta.x);
lObject.OriginPosition.Y += (short)(lDelta.y);
lObject.OriginPosition.Z -= (short)(lDelta.z);
}
RebuildObject(ActiveObject);
InvalidateAllViewers();
}
void Viewer3DRenderingSurface_MouseMove(object sender, MouseEventArgs e)
{
if (!mDraggingView || mSubject == null)
{
return;
}
System.Drawing.Point lNewMousePoint = e.Location;
RenderingSurface lSender = sender as RenderingSurface;
Camera lCamera = mViews[lSender].Camera;
if (mDraggingButton == MouseButtons.Left)
{
if (Control.ModifierKeys == Keys.Alt && lCamera.ProjectionMode == eProjectionMode.Orthographic)
{
IPositionable lObject = ActiveObject as IPositionable;
if (lObject != null)
{
double lDeltaX = (lNewMousePoint.X - mLastMouseDown.X);
// Origin is at bottom-left, but mouse position is measured from orign at top-left (or vice versa)
double lDeltaY = -(lNewMousePoint.Y - mLastMouseDown.Y);
double lScale = (lCamera.Position.GetPositionVector() * lCamera.ZAxis) / lSender.Width;
Vector lDelta = ((lDeltaX * lCamera.XAxis) + (lDeltaY * lCamera.YAxis)) * lScale;
lObject.OriginPosition.X += (short)(lDelta.x);
lObject.OriginPosition.Y += (short)(lDelta.y);
// MMs has a left handed coordinate system, so the z-axis is pointing the "wrong" way
lObject.OriginPosition.Z -= (short)(lDelta.z);
RebuildObject(lObject);
InvalidateAllViewers();
}
}
else if (Control.ModifierKeys == Keys.Shift)
{
IRotatable lObject = ActiveObject as IRotatable;
if (lObject != null)
{
double lDelta = (double)(lNewMousePoint.Y - mLastMouseDown.Y);
lObject.RotationVector = Utils.RotationMatrixToShort3Coord(
Matrix.Rotation(lDelta / 100, lCamera.ZAxis) * Utils.Short3CoordToRotationMatrix(lObject.RotationVector));
RebuildObject(lObject);
InvalidateAllViewers();
}
}
else if (lCamera.ProjectionMode == eProjectionMode.Perspective)
{
switch (MovementMode)
{
case eMovementMode.FlyMode:
bool lCameraIsUpsideDown = lCamera.YAxis.Dot(Vector.ZAxis) < 0;
lCamera.Rotate(0.01 * (lNewMousePoint.X - mLastMouseDown.X), lCameraIsUpsideDown ? Vector.ZAxis : -Vector.ZAxis);
lCamera.Rotate(0.01 * (lNewMousePoint.Y - mLastMouseDown.Y), lCamera.XAxis);
break;
case eMovementMode.InspectMode:
lCamera.RotateAboutWorldOrigin(0.01 * (lNewMousePoint.X - mLastMouseDown.X), lCamera.YAxis);
lCamera.RotateAboutWorldOrigin(0.01 * (lNewMousePoint.Y - mLastMouseDown.Y), lCamera.XAxis);
break;
default: throw new Exception("Unreachable case");
}
}
}
if (mDraggingButton == MouseButtons.Right)
{
if (Control.ModifierKeys == Keys.Alt)
{
}
else if (Control.ModifierKeys == Keys.Shift)
{
}
else
{
if (lCamera.ProjectionMode == eProjectionMode.Orthographic)
{
double lScale = (lCamera.Position.GetPositionVector() * lCamera.ZAxis) / lSender.Width;
lCamera.Move(-lScale * (lNewMousePoint.X - mLastMouseDown.X) * lCamera.XAxis);
lCamera.Move(lScale * (lNewMousePoint.Y - mLastMouseDown.Y) * lCamera.YAxis);
}
else
{
if (lCamera.ProjectionMode == eProjectionMode.Perspective && MovementMode == eMovementMode.FlyMode)
{
lCamera.Move(0.1 * MoveScale * (lNewMousePoint.X - mLastMouseDown.X) * lCamera.XAxis);
lCamera.Move(0.1 * MoveScale * (lNewMousePoint.Y - mLastMouseDown.Y) * lCamera.YAxis);
}
}
}
}
mLastMouseDown = lNewMousePoint;
lSender.Invalidate();
}
private static async Task MoveTopCornerToBottom(IRotatable configuration, ICollection<IRotation> solution)
{
// Move into top layer
await CommonActions.ApplyAndAddRotation(Rotations.RightClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.Upper2, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightAntiClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.UpperAntiClockwise, solution, configuration).ConfigureAwait(false);
// Move to bottom face
await CommonActions.ApplyAndAddRotation(Rotations.RightClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.UpperClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightAntiClockwise, solution, configuration).ConfigureAwait(false);
}
public static bool IsHorizontal(IRotatable symbol)
{
Rotation rotation = symbol.Rotation;
return(rotation == Rotation.Right || rotation == Rotation.Left);
}
public void Construct(IRotatable rotatable, ISpawner <Photon> spawner, IWave wave)
{
this.rotatable = rotatable;
this.spawner = spawner;
this.wave = wave;
}
private static async Task MoveTopCentreToMiddleRight(IRotatable configuration, ICollection<IRotation> solution)
{
await CommonActions.ApplyAndAddRotation(Rotations.UpperClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.UpperAntiClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightAntiClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.FrontClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightAntiClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.FrontAntiClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightClockwise, solution, configuration).ConfigureAwait(false);
}
public static void simulateMovement(IRotatable obj, GameTime time)
{
obj.RotationAngle += obj.AngularVelocity * (float)time.ElapsedGameTime.TotalSeconds;
}
private static async Task HorizontalLineToCross(IRotatable configuration, ICollection<IRotation> solution)
{
await CommonActions.ApplyAndAddRotation(Rotations.FrontClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.UpperClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightAntiClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.UpperAntiClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.FrontAntiClockwise, solution, configuration).ConfigureAwait(false);
}
private static async Task<bool> PermuteAllSame(Dictionary<FaceType, RelativePosition> relativePositions, IRotatable configuration, ICollection<IRotation> solution)
{
if (relativePositions == null || !relativePositions.Any()) return false;
var first = relativePositions.First().Value;
if (relativePositions.Values.Skip(1).Any(p => p != first)) return false;
switch (first)
{
case RelativePosition.Right:
await CommonActions.ApplyAndAddRotation(Rotations.UpperAntiClockwise, solution, configuration).ConfigureAwait(false);
break;
case RelativePosition.Left:
await CommonActions.ApplyAndAddRotation(Rotations.UpperClockwise, solution, configuration).ConfigureAwait(false);
break;
case RelativePosition.Opposite:
await CommonActions.ApplyAndAddRotation(Rotations.Upper2, solution, configuration).ConfigureAwait(false);
break;
}
return true;
}
/// <summary>
/// Gets the orientation of the browser.
/// </summary>
/// <returns>A value containing the orientation of the browser.</returns>
public override object Execute()
{
IRotatable rotatableDriver = Session.Driver as IRotatable;
return(rotatableDriver.Orientation.ToString().ToUpperInvariant());
}
private static async Task RightFace(ICollection<IRotation> solution, IRotatable configuration)
{
for (int i = 0; i < 2; i++)
{
await CommonActions.ApplyAndAddRotation(Rotations.RightClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.DownClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.RightAntiClockwise, solution, configuration).ConfigureAwait(false);
await CommonActions.ApplyAndAddRotation(Rotations.DownAntiClockwise, solution, configuration).ConfigureAwait(false);
}
}
