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;
}
