public void AddNDirectionsToList(List <EnumDirection> directions, EnumDirection direction, int n) { for (int i = 0; i < n; i++) { directions.Add(direction); } }
public void Left() { int direction = (int)FacingDirection; direction = (direction + 3) % 4; FacingDirection = (EnumDirection)direction; }
public Location(double value, EnumLocationType type) { int[] degmin = AstroUtility.GetDegreeMinuteSeconds(value); DegValue = Math.Abs(degmin[0]); MinuteValue = Math.Abs(degmin[1]); DirectionValue = this.ofVal(value, type); }
private void ArrowsClick(EnumDirection arrow) { if (!IsMouseDown) { var curPos = Mouse.GetPosition(BorderSlider); var setMouse = BorderSlider.PointToScreen(mCenter); var value = curPos - mCenter; if (ControlPressed) { value.Y *= (precision * precision); value.X *= (precision * precision); } else { value.Y *= precision; value.X *= precision; } if (arrow == EnumDirection.X) { value.Y = 0.0; } else { value.X = 0.0; } UpdatePosition(value, arrow); } }
public void Right() { int direction = (int)FacingDirection; direction = (direction + 1) % 4; FacingDirection = (EnumDirection)direction; }
internal void UpdatePosition(Vector value, EnumDirection direction) { if (_cancelTask != null) { _cancelTask.Cancel(true); } if (direction == EnumDirection.Both || direction == EnumDirection.X) { } if (direction == EnumDirection.Both || direction == EnumDirection.Y) { if (value.Y > 0.0) { } else if (value.Y < 0.0) { } } if (UpdatePositionEvent != null) { UpdatePositionEvent(this, value, direction); } }
public static void Move(EnumDirection dir, MazeObject movee) { switch (dir) { case EnumDirection.Up: SwapUpDown(movee.getSurroundings().GetUp(), movee); break; case EnumDirection.Down: SwapUpDown(movee, movee.getSurroundings().GetDown()); break; case EnumDirection.Left: SwapLeftRight(movee, movee.getSurroundings().GetLeft()); break; case EnumDirection.Right: SwapLeftRight(movee.getSurroundings().GetRight(), movee); break; default: throw new UnauthorizedAccessException(); } }
public void EndAutoScroll() { xDirection = 0; yDircetion = 0; isAutoScroll = false; currDirection = EnumDirection.None; }
/// <summary> /// Add the object to specific list of object /// </summary> /// <param name="id">input id</param> /// <param name="value">input value base 64</param> /// <param name="direction">direction Right/Left</param> internal static void AddToStorage(string id, string value, EnumDirection direction) { var list = FindAll(id); switch (direction) { case EnumDirection.Right: if (list.Count == 0) { Diff.StorageDiff.Add(new Diff() { id = id, right = value }); } else { list.FindLast(x => x.id.Equals(id)).right = value; } break; case EnumDirection.Left: if (list.Count == 0) { Diff.StorageDiff.Add(new Diff() { id = id, left = value }); } else { list.FindLast(x => x.id.Equals(id)).left = value; } break; } }
public void TriggerAutoScroll(EnumDirection direction) { if (currDirection == direction) { return; } isAutoScroll = true; switch (direction) { case EnumDirection.Up: yDircetion = 1; break; case EnumDirection.Right: xDirection = 1; break; case EnumDirection.Bottom: yDircetion = -1; break; case EnumDirection.Left: xDirection = -1; break; } currDirection = direction; }
public Port(AbstractPlacedItem item, int x, int z, EnumDirection direction) { Assert.IsTrue(item != null); this.me = item; portCenter = new Vector3(x, 0f, z); this.direction = direction; output = null; }
/// <summary> /// Gelen kordinattan başlayarak istenilen yönde hareket ettikten sonra robotun koordinatını ve yönünü hesaplamak için kullanılan metod. /// </summary> /// <param name="maxPoints">1, 2 gibi istenilen board genişliğini aşmayan sayılar olmalı</param> /// <param name="tasks">L,M,R Harflerinden oluşmalı</param> public void Step(List <int> maxPoints, string tasks) { foreach (var task in tasks) { switch (task) { case 'M': StepForDirection(); break; case 'L': Direction = Rotate90Left[Direction]; break; case 'R': Direction = Rotate90Right[Direction]; break; default: Console.WriteLine($"Invalid Character {task}"); break; } if (X < 0 || X > maxPoints[0] || Y <0 || Y> maxPoints[1]) { throw new Exception($"Entered position values can not be beyond bounderies (0 , 0) and ({maxPoints[0]} , {maxPoints[1]})"); } } }
//Moving pacman public void ChangePositionByDirection(EnumDirection Direction) { if (coordinate.x > 27) { coordinate.x = 0; } else if (coordinate.x < 0) { coordinate.x = 27; } Program.map.RenderObject(coordinate, this); if (Direction == EnumDirection.Left) { coordinate.x--; } if (Direction == EnumDirection.Right) { coordinate.x++; } if (Direction == EnumDirection.Up) { coordinate.y--; } if (Direction == EnumDirection.Down) { coordinate.y++; } CalcScore(); Program.map.RenderObject(coordinate, this); }
public override void interact(EnumDirection dir) { this.setLastMove(dir); MazeObject interaction = getInteractionObject(dir); interaction.interact(this); }
public void NonContraryDirectionTest(EnumDirection firstDir, EnumDirection nonContraryDir) { SnakeDirection direction = new SnakeDirectionBuilder().WhereDirection(firstDir).Build(); SnakeDirection nonContraryDirection = new SnakeDirectionBuilder().WhereDirection(nonContraryDir).Build(); Assert.False(direction.IsDirectionsContrary(nonContraryDirection)); Assert.False(nonContraryDirection.IsDirectionsContrary(direction)); }
public void ContraryDirectionTest(EnumDirection firstDir, EnumDirection contraryDir) { SnakeDirection direction = new SnakeDirectionBuilder().WhereDirection(firstDir).Build(); SnakeDirection contraryDirection = new SnakeDirectionBuilder().WhereDirection(contraryDir).Build(); Assert.True(direction.IsDirectionsContrary(contraryDirection)); Assert.True(contraryDirection.IsDirectionsContrary(direction)); }
public static bool QueryNearbyLocation(int startingRow, int startingColumn, EnumDirection direction, int distance, out Tile tile) //return true if there is a tile, false if there isn't { //if there's a tile in the location, return the tile int?candidateRow; int?candidateColumn; //work out the candidate coordinates switch (direction) { case EnumDirection.Left: //Console.WriteLine("Left"); candidateRow = startingRow - distance; candidateColumn = startingColumn; break; case EnumDirection.Right: //Console.WriteLine("Right"); candidateRow = startingRow + distance; candidateColumn = startingColumn; break; case EnumDirection.Up: //Console.WriteLine("Up"); candidateRow = startingRow; candidateColumn = startingColumn - distance; break; case EnumDirection.Down: //Console.WriteLine("Down"); candidateRow = startingRow; candidateColumn = startingColumn + distance; break; default: Console.WriteLine("Invalid direction"); candidateRow = -1; candidateColumn = -1; break; } if (candidateRow < 0 || candidateColumn < 0) //if the position doesn't exist, return null { //Console.WriteLine($"coordinate {candidateX}:{candidateY} does not exist"); tile = null; return(false); } else if (IsEmptyPosition((int)candidateRow, (int)candidateColumn)) // the position exists, but there's nothing in it, return null { //Console.WriteLine($"coordinate {candidateX}:{candidateY} is empty"); tile = null; return(false); } else { tile = tileGrid[(int)candidateRow, (int)candidateColumn]; //Console.WriteLine($"Tile {tile.Colour}:{tile.Shape} found at coordinate {candidateX}:{candidateY} (by coordinates)"); return(true); //if there's a tile in the position, return it. } }
public Character(string name, EnumCharacterModel model) { Id = Guid.NewGuid(); Name = name; Model = model; _builds = new CharacterBuild[3]; Direction = EnumDirection.SOUTH; }
/// <summary> /// Ajoute le nombre nombre de missile possédé par une entité dans sa liste /// </summary> /// <param name="a_weaponSlot"></param> /// <param name="a_missileDirection"></param> public void InitBasesMissiles(int a_weaponSlot, EnumDirection a_missileDirection) { _missiles = new List <Missile>(); for (int i = 0; i < a_weaponSlot; i++) { _missiles.Add(new Missile(a_missileDirection)); } }
/// <summary> /// 移动角色菜单 /// </summary> public ActionResult MoveRoleMenu(IList<Guid> menuGuid, EnumDirection operateType, Guid? userID) { ModelSysUserRightManageMoveRoleMenu model = new ModelSysUserRightManageMoveRoleMenu(); model.UserID = userID; model.MenuGuid = menuGuid; model.OperateType = operateType; model.RetriveData(); return RedirectToAction("Index", "SysUserRightManage", new { id = userID }); }
public void ChangeSnakeDirectionToCurrentTest() { EnumDirection newDirection = gameManager.GetGameBoard(curGameGuid).SnakeDirection; ActionResult actionResult = controller.PatchDirection(curGameGuid, new SnakeDirection { Direction = newDirection }); Assert.IsInstanceOf <OkResult>(actionResult); Assert.AreEqual(newDirection, gameManager.GetGameBoard(curGameGuid).SnakeDirection); }
/// <summary> /// Проверяет корретно ли задано направление /// </summary> public static bool IsDirectionOk(this SnakeDirection dir) { EnumDirection enumVal = dir.Direction; if (enumVal == EnumDirection.Left || enumVal == EnumDirection.Right || enumVal == EnumDirection.Top || enumVal == EnumDirection.Bottom) { return(true); } return(false); }
public Ammo ( Tank source, Point position, EnumDirection direction ) { _direction = direction; _sourceTank = source; Position = position; _imgAmmo = new Bitmap("Resources/ammo.bmp"); }
/** * Perform a 2D FFT inplace given a complex 2D array * The direction dir, 1 for forward, -1 for reverse * The size of the array (nx,ny) * Return false if there are memory problems or * the dimensions are not powers of 2 */ public static ComplexNumber[,] fft2d(ComplexNumber[,] c, int nx, int ny, EnumDirection direction) { int i, j; int m;//Power of 2 for current number of points double [] real; double [] imag; ComplexNumber [,] output; //=new COMPLEX [nx,ny]; output = c; // Copying Array // Transform the Rows real = new double[nx]; imag = new double[nx]; for (j = 0; j < ny; j++) { for (i = 0; i < nx; i++) { real[i] = c[i, j].real; imag[i] = c[i, j].imag; } // Calling 1D FFT Function for Rows m = (int)System.Math.Log((double)nx, 2);//Finding power of 2 for current number of points e.g. for nx=512 m=9 fft1d(direction, m, ref real, ref imag); for (i = 0; i < nx; i++) { output[i, j].real = real[i]; output[i, j].imag = imag[i]; } } // Transform the columns real = new double[ny]; imag = new double[ny]; for (i = 0; i < nx; i++) { for (j = 0; j < ny; j++) { real[j] = output[i, j].real; imag[j] = output[i, j].imag; } // Calling 1D FFT Function for Columns m = (int)System.Math.Log((double)ny, 2);//Finding power of 2 for current number of points e.g. for nx=512 m=9 fft1d(direction, m, ref real, ref imag); for (j = 0; j < ny; j++) { output[i, j].real = real[j]; output[i, j].imag = imag[j]; } } return(output); }
/// <summary> /// Change IsMouseDown state /// </summary> private void Slider_MouseUp(object sender, MouseButtonEventArgs e) { IsMouseDown = false; IsMouseReseting = 0; shiftPressed = false; direction = EnumDirection.Both; target.ReleaseMouseCapture(); arrowX.Visibility = System.Windows.Visibility.Visible; arrowY.Visibility = System.Windows.Visibility.Visible; arrowX.Width = constBigArrows; arrowY.Width = constBigArrows; }
/// <summary> /// Constructeur renseigné /// </summary> /// <param name="a_shape"></param> /// <param name="a_position"></param> /// <param name="a_nbrMissile"></param> /// <param name="a_missileDirection"></param> public Entity(string a_shape, Position a_position, int a_nbrMissile, EnumDirection a_missileDirection) { _shape = new Shape(a_shape); _hitBox = new HitBox(a_position, a_shape); _position = a_position; _lifePoints = 1; _weaponSlot = a_nbrMissile; _missileDirection = a_missileDirection; InitBasesMissiles(_weaponSlot, _missileDirection); }
public static int OffsetX(this EnumDirection dir) { switch (dir) { case EnumDirection.EAST: return(1); case EnumDirection.WEST: return(-1); } return(0); }
public static int OffsetY(this EnumDirection dir) { switch (dir) { case EnumDirection.SOUTH: return(1); case EnumDirection.NORTH: return(-1); } return(0); }
/// <summary> /// Calculate Fast Fourier Transform of Input Image /// </summary> public void doFft(EnumDirection direction) { int directionAsInt; if (direction == EnumDirection.FORWARD) { directionAsInt = 1; } else { directionAsInt = -1; } //Initializing Fourier Transform Array //int i,j; /****Fourier =new ComplexNumber [Width,Height];****/ Output = new ComplexNumber[Width, Height]; //Copy Image Data to the Complex Array /***for (i=0;i<=Width -1;i++) * for (j = 0; j <= Height - 1; j++) * { * Fourier[i, j].real =(double) GreyImage[i, j]; * Fourier[i, j].imag = 0; * }***/ //Calling Forward Fourier Transform Output = fft2d(Fourier, nx, ny, direction); if (direction == EnumDirection.BACKWARD) { int x, y; inverseResult = new double[Width, Height]; for (y = 0; y < Height; y++) { for (x = 0; x < Width; x++) { inverseResult[x, y] = Output[x, y].Magnitude(); } } } else { inverseResult = null; } return; }
public bool move(EnumDirection dir) { switch (dir) { case EnumDirection.Right: if (_surroundings.getRight().swappable()) { MazeObject temp = _surroundings.getRight().getObject(); _surroundings.getRight().setObject(_occupiedBy); _occupiedBy = temp; return true; } return false; case EnumDirection.Left: if (_surroundings.getLeft().swappable()) { MazeObject temp = _surroundings.getLeft().getObject(); _surroundings.getLeft().setObject(_occupiedBy); _occupiedBy = temp; return true; } return false; case EnumDirection.Up: if (_surroundings.getUp().swappable()) { MazeObject temp = _surroundings.getUp().getObject(); _surroundings.getUp().setObject(_occupiedBy); _occupiedBy = temp; return true; } return false; case EnumDirection.Down: if (_surroundings.getDown().swappable()) { MazeObject temp = _surroundings.getDown().getObject(); _surroundings.getDown().setObject(_occupiedBy); _occupiedBy = temp; return true; } return false; default: return false; }//end switch }
public Cell GetCellByDirection(EnumDirection Direction) { if (Direction == EnumDirection.Left) { return(Program.map[coordinate.x - 1, coordinate.y]); } if (Direction == EnumDirection.Right) { return(Program.map[coordinate.x + 1, coordinate.y]); } if (Direction == EnumDirection.Up) { return(Program.map[coordinate.x, coordinate.y - 1]); } return(Program.map[coordinate.x, coordinate.y + 1]); }
/// <summary> /// return an EnumDirection from a string /// </summary> /// <param name="strDir"></param> /// <returns></returns> public static EnumDirection stringToDirection(String strDir) { EnumDirection orientation = new EnumDirection(); switch (strDir) { case "east": orientation = EnumDirection.East; break; case "diagonalSouthEast": orientation = EnumDirection.DiagonalSouthEast; break; case "southEast": orientation = EnumDirection.SouthEast; break; case "diagonalSouth": orientation = EnumDirection.DiagonalSouth; break; case "southWest": orientation = EnumDirection.SouthWest; break; case "diagonalSouthWest": orientation = EnumDirection.DiagonalSouthWest; break; case "west": orientation = EnumDirection.West; break; case "diagonalNorthWest": orientation = EnumDirection.DiagonalNorthWest; break; case "northWest": orientation = EnumDirection.NorthWest; break; case "diagonalNorth": orientation = EnumDirection.DiagonalNorth; break; case "northEast": orientation = EnumDirection.NorthEast; break; case "diagonalNorthEast": orientation = EnumDirection.DiagonalNorthEast; break; case "default": orientation = EnumDirection.Default; break; } return orientation; }
private void Shuffle() { EnumAxis axis = (EnumAxis)UnityEngine.Random.Range(0, 3); int slice = UnityEngine.Random.Range(0, 3); while (slice == lastSlice) { slice = UnityEngine.Random.Range(0, 3); } lastSlice = slice; EnumDirection direction = (EnumDirection)UnityEngine.Random.Range(0, 2); CubeController.Instance.StartRotation(axis, EnumAnimType.slice, direction, slice, 1200f); }
public MazeMap Generate(int sizeX, int sizeY) { MazeMap map = new MazeMap(sizeX, sizeY); List <MapPos> pending = new List <MapPos>(); pending.Add(new MapPos(map.Width() / 2, map.Height() / 2)); EnumDirection?lastDir = null; while (pending.Count > 0) { MapPos curPos = pending[0]; int curSeg = map.GetSegment(curPos); List <EnumDirection> dirs = GetEmptySides(map, curPos, lastDir); if (lastDir.HasValue) { curSeg |= lastDir.Value.Opposite().BitMask(); map.SetSegment(curPos, curSeg); } if (dirs.Count <= 0) { lastDir = null; pending.RemoveAt(0); pending.Shuffle(rand); } else { EnumDirection nxtDir = dirs[rand.Next(dirs.Count)]; curSeg |= nxtDir.BitMask(); map.SetSegment(curPos, curSeg); lastDir = nxtDir; if (dirs.Count == 1) { pending.RemoveAt(0); } pending.Insert(0, curPos.Offset(nxtDir)); } } return(map); }
public static float GetAngle(this EnumDirection direction) { switch (direction) { default: case EnumDirection.North: return(0f); case EnumDirection.East: return(90f); case EnumDirection.South: return(180f); case EnumDirection.West: return(270f); } }
//could this go somewhere else? -- where? private MazeObject GetInteractionObject(EnumDirection dir) { switch (dir) { case EnumDirection.Up: return _surroundings.GetUp(); case EnumDirection.Down: return _surroundings.GetDown(); case EnumDirection.Left: return _surroundings.GetLeft(); case EnumDirection.Right: return _surroundings.GetRight(); default: throw new FieldAccessException(); } }
public static EnumDirection Rotate(EnumDirection source, int rotateValue) { //Logger.Error("source : " + source.ToString() + " Dest : " + ((EnumDirection)(((int)source + rotateValue) % 12)).ToString()); return (EnumDirection)(((int)source + rotateValue) % 12); }
/// <summary> /// Calculate Fast Fourier Transform of Input Image /// </summary> public void doFft(EnumDirection direction) { int directionAsInt; if( direction == EnumDirection.FORWARD ) { directionAsInt = 1; } else { directionAsInt = -1; } //Initializing Fourier Transform Array //int i,j; /****Fourier =new ComplexNumber [Width,Height];****/ Output = new ComplexNumber[Width, Height]; //Copy Image Data to the Complex Array /***for (i=0;i<=Width -1;i++) for (j = 0; j <= Height - 1; j++) { Fourier[i, j].real =(double) GreyImage[i, j]; Fourier[i, j].imag = 0; }***/ //Calling Forward Fourier Transform Output = fft2d(Fourier, nx, ny, directionAsInt); if( direction == EnumDirection.BACKWARD ) { int x, y; inverseResult = new double[Width, Height]; for( y = 0; y < Height; y++ ) { for( x = 0; x < Width; x++ ) { inverseResult[x, y] = Output[x, y].Magnitude(); } } } else { inverseResult = null; } return; }
public void Interact(EnumDirection dir) { this.SetLastMove(dir); MazeObject interaction = GetInteractionObject(dir); interaction.Interact(this); }
protected bool move(EnumDirection dir) { MazeMover.move(dir, this); return false; }
/// <summary> /// 移动用户所属角色 /// </summary> /// <param name="nonAssignedUserID"></param> /// <param name="assignedUserList"></param> /// <param name="operateType"></param> /// <param name="sysRoleID"></param> /// <returns></returns> public ActionResult MoveUsers(IList<Guid> nonAssignedUserList, IList<Guid> assignedUserList, EnumDirection operateType, Guid? sysRoleID) { ModelSysRoleManageMoveUsers model = new ModelSysRoleManageMoveUsers(); model.SysRoleID = sysRoleID; model.OperateType = operateType; model.NonAssignedUserList = nonAssignedUserList; model.AssignedUserList = assignedUserList; model.RetriveData(); return RedirectToAction("BelongsRole", "SysRoleManage", new { id = sysRoleID }); }
public void SetLastMove(EnumDirection dir) { _lastMoveDirection = dir; }
/// <summary> /// 移动用户类型菜单 /// </summary> /// <param name="menuGuid"></param> /// <param name="operateType"></param> /// <param name="sysRoleID"></param> /// <returns></returns> public ActionResult MoveUserTypeMenu(IList<Guid> menuGuid, EnumDirection operateType, Guid? sysUserTypeID) { ModelSysUserTypeManageMoveUserTypeMenu model = new ModelSysUserTypeManageMoveUserTypeMenu(); model.SysUserTypeID = sysUserTypeID; model.MenuGuid = menuGuid; model.OperateType = operateType; Error = model.MoveMenu(); return RedirectToAction("Index", "SysUserTypeManage", new { SysUserTypeID = sysUserTypeID}); }
public static int GetDiff(EnumDirection source, EnumDirection dest) { //Logger.Error(((dest - source) + 12) % 12); return ((dest - source)+12)%12; }
public static int GetDiffAngle(EnumDirection source, EnumDirection dest) { return (GetDiff(source, dest) - 6) * 30; }