public static void ResizeArray <T>(ref T[,] array, int width, int height, Direction8 dir, bool initialize) where T : new() { Direction4 vert = Direction4.None; Direction4 horiz = Direction4.None; DecomposeDiagonal(dir, ref horiz, ref vert); Loc2D offset = new Loc2D(); if (horiz == Direction4.None) { offset.X = (width - array.GetLength(0)) / 2; } else if (horiz == Direction4.Left) { offset.X = (width - array.GetLength(0)); } if (vert == Direction4.None) { offset.Y = (height - array.GetLength(1)) / 2; } else if (vert == Direction4.Up) { offset.Y = (height - array.GetLength(1)); } T[,] returnArray = new T[width, height]; if (initialize) { for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { if (x >= offset.X && x < offset.X + array.GetLength(0) && y >= offset.Y && y < offset.Y + array.GetLength(1)) { returnArray[x, y] = array[x - offset.X, y - offset.Y]; } else { returnArray[x, y] = new T(); } } } } else { for (int x = Math.Max(-offset.X, 0); x < array.GetLength(0) && x + offset.X < returnArray.GetLength(0); x++) { for (int y = Math.Max(-offset.Y, 0); y < array.GetLength(1) && y + offset.Y < returnArray.GetLength(1); y++) { returnArray[x + offset.X, y + offset.Y] = array[x, y]; } } } array = returnArray; }
public float TryToMove(float distance, Direction4 direction, Vector2 deltaPosition = default) { float allowedMove = GetAllowedMovement(distance, direction, deltaPosition); float effectiveMove = ForceMove(allowedMove, direction); return(effectiveMove); }
public static void Draw(Bounds bounds, Direction4 direction, float length = 1f) { if (direction.IsHorizontal()) { Vector2 originTop = (Vector2)bounds.center + new Vector2(bounds.extents.x * direction.Sign(), bounds.extents.y); Debug.DrawLine(originTop, originTop + direction.ToVector2(length), Color.magenta); Vector2 originCenter = (Vector2)bounds.center + new Vector2(bounds.extents.x * direction.Sign(), 0); Debug.DrawLine(originCenter, originCenter + direction.ToVector2(length), Color.magenta); Vector2 originBottom = (Vector2)bounds.center + new Vector2(bounds.extents.x * direction.Sign(), -bounds.extents.y); Debug.DrawLine(originBottom, originBottom + direction.ToVector2(length), Color.magenta); } else { Vector2 originLeft = (Vector2)bounds.center + new Vector2(-bounds.extents.x, bounds.extents.y * direction.Sign()); Debug.DrawLine(originLeft, originLeft + direction.ToVector2(length), Color.magenta); Vector2 originCenter = (Vector2)bounds.center + new Vector2(0, bounds.extents.y * direction.Sign()); Debug.DrawLine(originCenter, originCenter + direction.ToVector2(length), Color.magenta); Vector2 originRight = (Vector2)bounds.center + new Vector2(bounds.extents.x, bounds.extents.y * direction.Sign()); Debug.DrawLine(originRight, originRight + direction.ToVector2(length), Color.magenta); } }
public static int DistanceInFront(int x1, int y1, int x2, int y2, Direction4 dir) { switch (dir) { case Direction4.Down: { return(y2 - y1); } case Direction4.Left: { return(x1 - x2); } case Direction4.Up: { return(y1 - y2); } case Direction4.Right: { return(x2 - x1); } default: return(0); } }
public static Loc2D GetResizeOffset(int oldWidth, int oldHeight, int width, int height, Direction8 dir) { Direction4 vert = Direction4.None; Direction4 horiz = Direction4.None; DecomposeDiagonal(dir, ref horiz, ref vert); Loc2D center = new Loc2D(); if (horiz == Direction4.None) { center.X += (width - oldWidth) / 2; } else if (horiz == Direction4.Left) { center.X += (width - oldWidth); } if (vert == Direction4.None) { center.Y += (height - oldHeight) / 2; } else if (vert == Direction4.Up) { center.Y += (height - oldHeight); } return(center); }
public static Direction4 ToDirection4(Vector2 velocity) { Direction4 dir = Direction4.EAST; if (Mathf.Abs(velocity.x) >= Mathf.Abs(velocity.y)) { if (velocity.x > 0) { dir = Direction4.EAST; } else { dir = Direction4.WEST; } } else { if (velocity.y > 0) { dir = Direction4.NORTH; } else { dir = Direction4.SOUTH; } } return(dir); }
public static Direction2V ToDirection2V(this Direction4 direction) { if (direction.IsHorizontal()) { throw new Exception("Passed horizontal direction4 in place of vertical"); } return(direction == Direction4.Up ? Direction2V.Up : Direction2V.Down); }
public static Direction2H ToDirection2H(this Direction4 direction) { if (direction.IsVertical()) { throw new Exception("Passed vertical direction4 in place of horizontal"); } return(direction == Direction4.Left ? Direction2H.Left : Direction2H.Right); }
public static Direction4 ReverseDir(Direction4 dir) { if ((int)dir <= (int)Direction4.None) { return(dir); } return((Direction4)(((int)dir + 2) % 4)); }
public static Direction4 Rotate(this Direction4 dir, int quaterClockwise) { while (quaterClockwise < 0) { quaterClockwise += 4; } return((Direction4)(((int)dir + quaterClockwise) % 4)); }
public CollisionMoveHit(Transform transform, Vector2 point, Vector2 normal, Direction4 rayDirection, float distanceToHit) { this.transform = transform; this.point = point; this.distanceToHit = distanceToHit; this.rayDirection = rayDirection; this.normal = normal; isTilemap = transform.CompareTag("Tilemap"); }
/// <summary> /// Rotates the direction a set amount of times /// </summary> /// <param name="dir4"></param> public static Direction4 Rotate(this Direction4 dir4, int times = 1) { if (times >= 0) { return((Direction4)(((int)dir4 + times * 2) % 8)); } throw new ArgumentException("Argument must be greater than or equal to zero"); }
private ColorPairPuyo CreateColorPuyo(PuyoType satellite, PuyoType pivot, Direction4 dir, int pos) { return(new ColorPairPuyo() { Pivot = pivot, Satellite = satellite, Dir = dir, Pos = pos, }); }
private IEnumerable <CollisionMoveHit> GetCollisionMoveHitsBelow() { float distance = RaycastHelpers.skinWidth; Direction4 direction = Direction4.Down; (RaycastHit2D[] hits, int count) = movement.raycaster.GetHits(distance, direction); IEnumerable <CollisionMoveHit> collisionMoveHits = movement.collisionMoveHitsFactory.GetUniqueRaycasterHits(hits, count, direction); return(collisionMoveHits); }
private float NoDistanceForceMove(Direction4 direction) { float distance = RaycastHelpers.skinWidth; IEnumerable <CollisionMoveHit> raycasterHits = GetCollisionMoveHits(distance, direction); foreach (CollisionMoveHit raycasterHit in raycasterHits) { collisionMoveController.ForceMoveInto(raycasterHit, 0); } return(0); }
public CollisionMoveHit(RaycastHit2D hit, Direction4 rayDirection) : this( transform : hit.transform, point : hit.point, normal : hit.normal, rayDirection : rayDirection, distanceToHit : hit.distance //distanceToHit: Mathf.Max(hit.distance - RaycastHelpers.skinWidth, 0) ) { }
public static void AssignDirDim(int x, int y, int p, Direction4 dir) { if (dir == Direction4.Down || dir == Direction4.Up) { y = p; } else { x = p; } }
public BackgroundParticle(int ox, int oy, Fraction f, float px, float py, Direction4 dir) { OriginX = ox; OriginY = oy; X = px; Y = py; Fraction = f; RemainingPower = INITIAL_POWER; Direction = dir; }
public static Direction4 AddDir(Direction4 dir1, Direction4 dir2) { if ((int)dir1 <= (int)Direction4.None) { return(dir2); } if ((int)dir2 <= (int)Direction4.None) { return(dir1); } return((Direction4)(((int)dir1 + (int)dir2) % 4)); }
static public int X(this Direction4 direction4) { switch (direction4) { case Direction4.Left: return(-1); case Direction4.Right: return(1); } return(0); }
public BackgroundParticle(BackgroundParticle source, float px, float py, Direction4 dir) { OriginX = source.OriginX; OriginY = source.OriginY; X = px; Y = py; Fraction = source.Fraction; RemainingPower = source.RemainingPower - 1; Direction = dir; }
static public int Y(this Direction4 direction4) { switch (direction4) { case Direction4.Up: return(1); case Direction4.Down: return(-1); } return(0); }
public void Inject(SnailController controller) { rigidbody = controller.di.physics.movement.rigidbody; if (forward) { dir4 = initialSurfaceNormal.RotateClockwise(); } else { dir4 = initialSurfaceNormal.RotateCounterClockwise(); } }
void MakeWall(Mass m, Direction4 d) { int newI = m.I, newJ = m.J; switch (d) { case Direction4.Up: newI = m.I - 1; break; case Direction4.Right: newJ = m.J + 1; break; case Direction4.Down: newI = m.I + 1; break; case Direction4.Left: newJ = m.J - 1; break; } maze[newI, newJ].MassState = State.Wall; }
public static void FillArray(int arrayWidth, int arrayHeight, TileCheck checkOp, TileOperation fillOp, Loc2D loc) { var stack = new Stack <StackItem>(); stack.Push(new StackItem(loc.X, loc.X, loc.Y, Direction4.None, true, true)); fillOp(loc.X, loc.Y); while (stack.Count > 0) { var item = stack.Pop(); int minX = item.MinX; int maxX = item.MaxX; int y = item.Y; Direction4 dir = item.Direction; bool goLeft = item.GoLeft; bool goRight = item.GoRight; int newMinX = minX; if (goLeft) { while (newMinX - 1 >= 0 && checkOp(newMinX - 1, y)) { newMinX--; fillOp(newMinX, y); } } int newMaxX = maxX; if (goRight) { while (newMaxX + 1 < arrayWidth && checkOp(newMaxX + 1, y)) { newMaxX++; fillOp(newMaxX, y); } } minX--; maxX++; if (y < arrayHeight - 1) { AddNextScanLine(checkOp, fillOp, minX, maxX, newMinX, newMaxX, y + 1, dir != Direction4.Up, Direction4.Down, stack); } if (y > 0) { AddNextScanLine(checkOp, fillOp, minX, maxX, newMinX, newMaxX, y - 1, dir != Direction4.Down, Direction4.Up, stack); } } }
public static void FillArray(int arrayWidth, int arrayHeight, TileCheck checkOp, TileOperation fillOp, Loc2D loc) { Stack <Tuple <int, int, int, Direction4, bool, bool> > stack = new Stack <Tuple <int, int, int, Direction4, bool, bool> >(); stack.Push(new Tuple <int, int, int, Direction4, bool, bool>(loc.X, loc.X, loc.Y, Direction4.None, true, true)); fillOp(loc.X, loc.Y); while (stack.Count > 0) { Tuple <int, int, int, Direction4, bool, bool> this_should_really_be_a_class = stack.Pop(); Direction4 dir = this_should_really_be_a_class.Item4; int minX = this_should_really_be_a_class.Item1; int maxX = this_should_really_be_a_class.Item2; int y = this_should_really_be_a_class.Item3; bool goLeft = this_should_really_be_a_class.Item5; bool goRight = this_should_really_be_a_class.Item6; int newMinX = minX; if (goLeft) { while (newMinX - 1 >= 0 && checkOp(newMinX - 1, y)) { newMinX--; fillOp(newMinX, y); } } int newMaxX = maxX; if (goRight) { while (newMaxX + 1 < arrayWidth && checkOp(newMaxX + 1, y)) { newMaxX++; fillOp(newMaxX, y); } } minX--; maxX++; if (y < arrayHeight - 1) { AddNextScanLine(checkOp, fillOp, minX, maxX, newMinX, newMaxX, y + 1, dir != Direction4.Up, Direction4.Down, stack); } if (y > 0) { AddNextScanLine(checkOp, fillOp, minX, maxX, newMinX, newMaxX, y - 1, dir != Direction4.Down, Direction4.Up, stack); } } }
public void DrawStraightPassage(Loc2D loc1, Loc2D loc2) { Loc2D diff = loc2 - loc1; Direction4 dir = (Math.Abs(diff.Y) > Math.Abs(diff.X)) ? Direction4.Down : Direction4.Right; Direction4 subDir = (dir == Direction4.Down) ? Direction4.Right : Direction4.Down; if (Operations.DimOfDir(diff.X, diff.Y, dir) < 0) { dir = Operations.ReverseDir(dir); } if (Operations.DimOfDir(diff.X, diff.Y, subDir) < 0) { subDir = Operations.ReverseDir(subDir); } Loc2D increment = new Loc2D(); Loc2D subIncrement = new Loc2D(); Operations.MoveInDirection4(ref increment, dir, 1); Operations.MoveInDirection4(ref subIncrement, subDir, 1); int change = Math.Abs(Operations.DimOfDir(diff.X, diff.Y, dir)); int subChange = Math.Abs(Operations.DimOfDir(diff.X, diff.Y, subDir)); int err = change / 2; Loc2D curLoc = loc1; int tileSize = rand.Next(minPassageSize, maxPassageSize + 1); int tileLimit = rand.Next(minSizeChangePeriod, maxSizeChangePeriod + 1); int tilesMoved = 0; while (Operations.DimOfDir(curLoc.X, curLoc.Y, dir) != Operations.DimOfDir(loc2.X, loc2.Y, dir)) { DrawPath(curLoc, tileSize); curLoc += increment; err -= subChange; if (err < 0) { curLoc += subIncrement; err += change; } tilesMoved++; if (tilesMoved >= tileLimit) { tileSize = rand.Next(minPassageSize, maxPassageSize + 1); tileLimit = rand.Next(minSizeChangePeriod, maxSizeChangePeriod + 1); tilesMoved = 0; } } DrawPath(loc2, tileSize); }
internal void Rotate90() { if (forward) { dir4 = dir4.RotateClockwise(); } else { dir4 = dir4.RotateCounterClockwise(); } transform.Rotate(new Vector3(0, 0, -90)); Physics2D.SyncTransforms(); }
public static Orientation4 GetOrientation4(Direction4 dir) { switch (dir) { case Direction4.Down: case Direction4.Up: return(Orientation4.Vert); case Direction4.Left: case Direction4.Right: return(Orientation4.Horiz); default: return(Orientation4.None); } }
public StackItem( int minX, int maxX, int y, Direction4 dir, bool goLeft, bool goRight ) { MinX = minX; MaxX = maxX; Y = y; Direction = dir; GoLeft = goLeft; GoRight = goRight; }
private float GetAllowedMovementAt_Obsolete(float distance, Direction4 direction, Vector2 deltaPosition = default) { if (!RaycastHelpers.IsValidDistance(distance)) { return(0); } IEnumerable <CollisionMoveHit> raycasterHits = GetCollisionMoveHits(distance, direction, deltaPosition); float allowedDistance = distance; foreach (CollisionMoveHit raycasterHit in raycasterHits) { allowedDistance = collisionMoveController.GetAllowedMoveInto(raycasterHit, allowedDistance); } return(allowedDistance); }
Mass MakeNewRoad(Mass m, Direction4 d) { int i = m.I, j = m.J; int newI = i, newJ = j; switch (d) { case Direction4.Up: newI = i - 2; break; case Direction4.Right: newJ = j + 2; break; case Direction4.Down: newI = i + 2; break; case Direction4.Left: newJ = j - 2; break; } maze[newI, newJ].MassState = State.Empty; return maze[newI, newJ]; }
public static float Sign(this Direction4 direction) { switch (direction) { case Direction4.Down: case Direction4.Left: return(-1f); case Direction4.Right: case Direction4.Up: return(1f); default: Debug.LogError($"Unhandled enum value: {direction}"); return(0f); } }
static public Vector2Int ToVector2Int(this Direction4 direction4) { switch (direction4) { case Direction4.Up: return(new Vector2Int(0, 1)); case Direction4.Down: return(new Vector2Int(0, -1)); case Direction4.Left: return(new Vector2Int(-1, 0)); case Direction4.Right: return(new Vector2Int(1, 0)); } return(new Vector2Int()); }
int BreakWall(Mass m, Direction4 d, Dictionary<int, List<Mass>> clustering) { int i = m.I, j = m.J; int newI = i, newJ = j; Mass newMass = null; switch (d) { case Direction4.Up: newI = i - 1; newMass = maze[i - 2, j]; break; case Direction4.Right: newJ = j + 1; newMass = maze[i, j + 2]; break; case Direction4.Down: newI = i + 1; newMass = maze[i + 2, j]; break; case Direction4.Left: newJ = j - 1; newMass = maze[i, j - 2]; break; } int minLabel = Math.Min(m.Label, newMass.Label), maxLabel = Math.Max(m.Label, newMass.Label); maze[newI, newJ].MassState = State.Empty; if (clustering.ContainsKey(maxLabel)) clustering[maxLabel].ForEach(c => c.Label = minLabel); return maxLabel; }
public static VehicleDirection12 ToVehicleDirection12(Direction4 direction) { switch (direction) { case Direction4.Up: return VehicleDirection12.VerticalUp; case Direction4.Down: return VehicleDirection12.VerticalDown; case Direction4.Left: return VehicleDirection12.HorizontalLeft; case Direction4.Right: return VehicleDirection12.HorizontalRight; default: throw new ArgumentOutOfRangeException("direction"); } }
void InventorySelectionMove(Direction4 dir) { if (dir == Direction4.Left) { inventoryselectedx--; } if (dir == Direction4.Right) { inventoryselectedx++; } if (dir == Direction4.Up) { inventoryselectedy--; } if (dir == Direction4.Down) { inventoryselectedy++; } inventoryselectedx = MyMath.Clamp(inventoryselectedx, 0, inventorysize - 1); inventoryselectedy = MyMath.Clamp(inventoryselectedy, 0, inventorysize - 1); }
Mass MakeNewWall(Mass m, Direction4 direction) { int i = m.I, j = m.J; int newI = i, newJ = j; switch (direction) { case Direction4.Up: newI = i - 2; break; case Direction4.Right: newJ = j + 2; break; case Direction4.Down: newI = i + 2; break; case Direction4.Left: newJ = j - 2; break; } if (maze[newI, newJ].MassState != State.Wall) maze[newI, newJ].MassState = State.NewWall; return maze[newI, newJ]; }