public void ChangeDirection(VectorDirection direction) { this.direction = direction; // reset out animation frame counter _frameIndex = 0; _directionChanged = true; }
public Vector(int offset, string reg, int count, VectorDirection dir) { Offset = offset; Register = reg; Count = count; Direction = dir;; }
public static Vector2Int GetVectorTowardsDirection(VectorDirection direction) { switch (direction) { case VectorDirection.North: return(NORTH); case VectorDirection.NorthEast: return(NORTH_EAST); case VectorDirection.NorthWest: return(NORTH_WEST); case VectorDirection.South: return(SOUTH); case VectorDirection.SouthEast: return(SOUTH_EAST); case VectorDirection.SouthWest: return(SOUTH_WEST); case VectorDirection.East: return(EAST); case VectorDirection.West: return(WEST); case VectorDirection.None: return(new Vector2Int(0, 0)); default: throw new Exception("Bad direction"); } }
public static void OnMovingInput(VectorDirection direction) { if (onPlayerMovingInput != null) { onPlayerMovingInput(direction); } }
public static VectorDirection GetVectorDirection(this Vector vector) { var x_ = vector.X; var y_ = vector.Y; VectorDirection V_ = 0; #if DEBUG Stopwatch st = new Stopwatch(); st.Start(); #endif if (double.IsNegative(x_) && double.IsNegative(y_)) { V_ = VectorDirection.AllNegative; } else if (double.IsNegative(x_) && double.IsNormal(y_)) { V_ = VectorDirection.NegativeX; } else if (double.IsNormal(x_) && double.IsNegative(y_)) { V_ = VectorDirection.NegativeY; } else if (!double.IsNegative(x_) && !double.IsNegative(y_)) { V_ = VectorDirection.AllPositive; } #if DEBUG st.Stop(); Debug.WriteLine($"measure direction takes {st.ElapsedMilliseconds} ms too long"); #endif return(V_); }
public ComputationResult(ComputationResult res, VectorDirection direction) { OdData = res.OdData; LiteralValue = res.LiteralValue; VectorData = res.VectorData; Direction = direction; }
/// <summary> /// Gets the vector R(n) or C(n) from the matrix /// </summary> /// <param name="mat">The matrix</param> /// <param name="direction">The direction to retrive the vector from (either rows or columns)</param> /// <param name="index">The index of the row or column</param> /// <returns>The vector at R(n) or C(n)</returns> public static T[] GetVector <T>(this T[,] mat, VectorDirection direction, int index) { T[] vector = new T[mat.GetDimensions().InDirection(direction)]; // if (vector.Length <= index){ // throw new IndexOutOfRangeException($"Index {index + 1} is larger than the size of the matrix axis {vector.Length}"); // } if (index < 1) { throw new IndexOutOfRangeException($"Index {index} is less than 1"); } if (direction == VectorDirection.Row) { for (int c = 0; c < vector.Length; c++) { vector[c] = mat[index - 1, c]; } } else { for (int r = 0; r < vector.Length; r++) { vector[r] = mat[r, index - 1]; } } return(vector); }
/// <summary> /// Converts a "smooth" jagged 2D array into a matrix /// </summary> /// <param name="jaggedArray">The "smooth" jagged 2D array</param> /// <param name="direction">The direction of the jagged 2D array's major axis</param> /// <returns>A matrix of the jagged 2D array</returns> public static T[,] ToMatrix <T>(this T[][] jaggedArray, VectorDirection direction) { if (jaggedArray.Length == 0) { throw new MatrixSizeException("A matrix cannot have zero elements"); } foreach (T[] arr in jaggedArray) { if (jaggedArray[0].Length != arr.Length) { throw new MatrixSizeException("A matrix cannot be jagged"); } } if (jaggedArray[0].Length == 0) { throw new MatrixSizeException("A matrix cannot have zero elements"); } if (direction == VectorDirection.Row) { return(new MatrixDimensions(jaggedArray.Length, jaggedArray[0].Length).CreateMatrix <T>().Apply((v, r, c) => jaggedArray[r - 1][c - 1])); } else { return(new MatrixDimensions(jaggedArray[0].Length, jaggedArray.Length).CreateMatrix <T>().Apply((v, r, c) => jaggedArray[c - 1][r - 1])); } }
protected override void OnPlayerInput(VectorDirection direction) { if (State.MovingMode != MoveMode.Snapping && _isMovingEnabled != false) { if (direction == VectorDirection.Up) { if (CanJump) { Jump(); SetAniamation("idle", true); } else if (CanReduceGravity) { gravity.ReduceGravity(); SetAniamation("fly", true); } return; } if ((direction == VectorDirection.Right && !_isFacingForward) || (direction == VectorDirection.Left && _isFacingForward)) { Flip(); } } _direction = direction; }
public void SetShoot(bool shoot, VectorDirection vectorDirection) { if (this.CanShoot()) { this.Shoot = shoot; } }
/// <summary> /// Inserts a row or column vector into a matrix /// </summary> /// <param name="mat">The matrix</param> /// <param name="direction">The type of vector to insert (row or column)</param> /// <param name="insertIndex">The vector index to insert at</param> /// <param name="vector">The vector to insert at the index. If not incuded or null, the vector is populated with default values.</param> /// <returns>The matrix with an additional row/column at the specified index</returns> public static T[,] InsertVector <T>(this T[,] mat, VectorDirection direction, int insertIndex, T[] vector = null) { MatrixDimensions d = mat.GetDimensions(); T[,] newMat; if (vector != null && d.InDirection(direction) != vector.Length) { throw new VectorSizeException("A vector cannot be inserted into a matrix of a different size"); } if (direction == VectorDirection.Column) { if (insertIndex > d.cols + 1 || insertIndex < 1) { throw new IndexOutOfRangeException("That column index does not and will not exist in the new matrix."); } newMat = new T[d.rows, d.cols + 1]; return(newMat.Apply((v, r, c) => { if (c < insertIndex) { return mat[r - 1, c - 1]; } else if (c > insertIndex) { return mat[r - 1, c - 2]; } if (vector != null) { return vector[r - 1]; } return v; })); } else { if (insertIndex > d.rows + 1 || insertIndex < 1) { throw new IndexOutOfRangeException("That row index does not and will not exist in the new matrix."); } newMat = new T[d.rows + 1, d.cols]; return(newMat.Apply((v, r, c) => { if (r < insertIndex) { return mat[r - 1, c - 1]; } else if (r > insertIndex) { return mat[r - 2, c - 1]; } if (vector != null) { return vector[c - 1]; } return v; })); } }
/// <summary> /// Applies a vector function to a matrix in a specified direction /// </summary> /// <param name="matrix">The matrix</param> /// <param name="direction">The direction of vector to apply on</param> /// <param name="f">The function to be applied over each vector in the matrix /// <para>Its arguments are the vector along the specified axis and the index of that vector.</para></param> /// <returns></returns> public static T[,] ApplyOverVector <T>(this T[,] matrix, VectorDirection direction, Func <T[], int, T[]> f) { T[][] arr = matrix.ToJagged(direction); for (int i = 0; i < arr.Length; i++) { arr[i] = f.Invoke(matrix.GetVector(direction, i + 1), i + 1); } return(arr.ToMatrix(direction)); }
/// <summary> /// Converts a matrix to a jagged 2D array /// </summary> /// <param name="matrix">The matrix</param> /// <param name="direction">The direction for the major axis of the jagged 2D array</param> /// <returns>A jagged 2D array of the matrix</returns> public static T[][] ToJagged <T>(this T[,] matrix, VectorDirection direction) { T[][] jaggedArray = new T[matrix.GetDimensions().InDirection(direction)][]; for (int i = 0; i < jaggedArray.Length; i++) { jaggedArray[i] = matrix.GetVector(direction, i + 1); } return(jaggedArray); }
/// <summary> /// Start this instance. /// </summary> private void Start() { // Make the transform the current parent if no object has been selected if (!tileTransform) { tileTransform = this.transform.parent; } orgTransformVector = VectorDirection.DetermineDirection(triggerDirection); oppTransformVector = VectorDirection.DetermineOppositeDirection(triggerDirection); }
public MoveTile() : base("moveTileUp0") { _leftFrameElements = new FAtlasElement[4]; _rightFrameElements = new FAtlasElement[4]; _upFrameElements = new FAtlasElement[4]; _downFrameElements = new FAtlasElement[4]; FAtlasManager am = Futile.atlasManager; _leftFrameElements[0] = am.GetElementWithName("moveTileLeft0"); _leftFrameElements[1] = am.GetElementWithName("moveTileLeft1"); _leftFrameElements[2] = am.GetElementWithName("moveTileLeft2"); _leftFrameElements[3] = am.GetElementWithName("moveTileLeft3"); _rightFrameElements[0] = am.GetElementWithName("moveTileRight0"); _rightFrameElements[1] = am.GetElementWithName("moveTileRight1"); _rightFrameElements[2] = am.GetElementWithName("moveTileRight2"); _rightFrameElements[3] = am.GetElementWithName("moveTileRight3"); _upFrameElements[0] = am.GetElementWithName("moveTileUp0"); _upFrameElements[1] = am.GetElementWithName("moveTileUp1"); _upFrameElements[2] = am.GetElementWithName("moveTileUp2"); _upFrameElements[3] = am.GetElementWithName("moveTileUp3"); _downFrameElements[0] = am.GetElementWithName("moveTileDown0"); _downFrameElements[1] = am.GetElementWithName("moveTileDown1"); _downFrameElements[2] = am.GetElementWithName("moveTileDown2"); _downFrameElements[3] = am.GetElementWithName("moveTileDown3"); _placedAt = 0.0f; int randomDirection = RXRandom.Range(0, 4); this.direction = VectorDirection.Up; // (VectorDirection)randomDirection; if (randomDirection == 1) { this.direction = VectorDirection.Left; this.element = _leftFrameElements[0]; } else if (randomDirection == 2) { this.direction = VectorDirection.Right; this.element = _rightFrameElements[0]; } else if (randomDirection == 3) { this.direction = VectorDirection.Down; this.element = _downFrameElements[0]; } ListenForUpdate(HandleUpdate); }
public Crew() : base("walkRight0") { this.defaultVelocity = 100; this.currentVelocity = this.defaultVelocity; int randomDirection = RXRandom.Range(0, 4); this.direction = VectorDirection.Up; // (VectorDirection)randomDirection; if (randomDirection == 1) { this.direction = VectorDirection.Left; } else if (randomDirection == 2) { this.direction = VectorDirection.Right; } else if (randomDirection == 3) { this.direction = VectorDirection.Down; } _leftFrameElements = new FAtlasElement[4]; _rightFrameElements = new FAtlasElement[4]; _upFrameElements = new FAtlasElement[4]; _downFrameElements = new FAtlasElement[4]; FAtlasManager am = Futile.atlasManager; _rightFrameElements[0] = am.GetElementWithName("walkRight0"); _rightFrameElements[1] = am.GetElementWithName("walkRight1"); _rightFrameElements[2] = am.GetElementWithName("walkRight2"); _rightFrameElements[3] = am.GetElementWithName("walkRight3"); _leftFrameElements[0] = am.GetElementWithName("walkLeft0"); _leftFrameElements[1] = am.GetElementWithName("walkLeft1"); _leftFrameElements[2] = am.GetElementWithName("walkLeft2"); _leftFrameElements[3] = am.GetElementWithName("walkLeft3"); _upFrameElements[0] = am.GetElementWithName("walkUp0"); _upFrameElements[1] = am.GetElementWithName("walkUp1"); _upFrameElements[2] = am.GetElementWithName("walkUp2"); _upFrameElements[3] = am.GetElementWithName("walkUp3"); _downFrameElements[0] = am.GetElementWithName("walkDown0"); _downFrameElements[1] = am.GetElementWithName("walkDown1"); _downFrameElements[2] = am.GetElementWithName("walkDown2"); _downFrameElements[3] = am.GetElementWithName("walkDown3"); ListenForUpdate(HandleUpdate); }
private void OnPlayerInput(VectorDirection direction) { if (State.MovingMode != MoveMode.Snapping && _isMovingEnabled != false && ( (direction == VectorDirection.Right && !_isFacingForward) || (direction == VectorDirection.Left && _isFacingForward) )) { Flip(); } _direction = direction; }
public MoveTile() : base("moveTileUp0") { _leftFrameElements = new FAtlasElement[4]; _rightFrameElements = new FAtlasElement[4]; _upFrameElements = new FAtlasElement[4]; _downFrameElements = new FAtlasElement[4]; FAtlasManager am = Futile.atlasManager; _leftFrameElements[0] = am.GetElementWithName("moveTileLeft0"); _leftFrameElements[1] = am.GetElementWithName("moveTileLeft1"); _leftFrameElements[2] = am.GetElementWithName("moveTileLeft2"); _leftFrameElements[3] = am.GetElementWithName("moveTileLeft3"); _rightFrameElements[0] = am.GetElementWithName("moveTileRight0"); _rightFrameElements[1] = am.GetElementWithName("moveTileRight1"); _rightFrameElements[2] = am.GetElementWithName("moveTileRight2"); _rightFrameElements[3] = am.GetElementWithName("moveTileRight3"); _upFrameElements[0] = am.GetElementWithName("moveTileUp0"); _upFrameElements[1] = am.GetElementWithName("moveTileUp1"); _upFrameElements[2] = am.GetElementWithName("moveTileUp2"); _upFrameElements[3] = am.GetElementWithName("moveTileUp3"); _downFrameElements[0] = am.GetElementWithName("moveTileDown0"); _downFrameElements[1] = am.GetElementWithName("moveTileDown1"); _downFrameElements[2] = am.GetElementWithName("moveTileDown2"); _downFrameElements[3] = am.GetElementWithName("moveTileDown3"); _placedAt = 0.0f; int randomDirection = RXRandom.Range(0, 4); this.direction = VectorDirection.Up; // (VectorDirection)randomDirection; if (randomDirection == 1){ this.direction = VectorDirection.Left; this.element = _leftFrameElements[0]; } else if (randomDirection == 2){ this.direction = VectorDirection.Right; this.element = _rightFrameElements[0]; } else if (randomDirection == 3){ this.direction = VectorDirection.Down; this.element = _downFrameElements[0]; } ListenForUpdate(HandleUpdate); }
void OnEnable() { if (objectToAnimate == null) { objectToAnimate = transform; } // The target position will be the original transform's position targetPosition = objectToAnimate.transform.position; // This will be the position where the object will appear from Vector3 fromPosition = targetPosition + (VectorDirection.DetermineDirection(directionToAnimateFrom) * animationScale); // Position the transform at the updated position objectToAnimate.transform.position = fromPosition; // Animate based on the chosen option switch (typeOfAnimation) { case AnimationTypes.FadeIn: StartCoroutine(FadeIn()); break; case AnimationTypes.Rotate: // StartCoroutine(Rotate()); break; case AnimationTypes.FadeOut: StartCoroutine(FadeOut()); break; case AnimationTypes.ZoomIn: StartCoroutine(ZoomIn()); break; case AnimationTypes.ZoomOut: StartCoroutine(ZoomOut()); break; case AnimationTypes.FadeZoomIn: StartCoroutine(FadeZoomIn()); break; default: break; } }
public Crew() : base("walkRight0") { this.defaultVelocity = 100; this.currentVelocity = this.defaultVelocity; int randomDirection = RXRandom.Range(0, 4); this.direction = VectorDirection.Up; // (VectorDirection)randomDirection; if (randomDirection == 1){ this.direction = VectorDirection.Left; } else if (randomDirection == 2){ this.direction = VectorDirection.Right; } else if (randomDirection == 3){ this.direction = VectorDirection.Down; } _leftFrameElements = new FAtlasElement[4]; _rightFrameElements = new FAtlasElement[4]; _upFrameElements = new FAtlasElement[4]; _downFrameElements = new FAtlasElement[4]; FAtlasManager am = Futile.atlasManager; _rightFrameElements[0] = am.GetElementWithName("walkRight0"); _rightFrameElements[1] = am.GetElementWithName("walkRight1"); _rightFrameElements[2] = am.GetElementWithName("walkRight2"); _rightFrameElements[3] = am.GetElementWithName("walkRight3"); _leftFrameElements[0] = am.GetElementWithName("walkLeft0"); _leftFrameElements[1] = am.GetElementWithName("walkLeft1"); _leftFrameElements[2] = am.GetElementWithName("walkLeft2"); _leftFrameElements[3] = am.GetElementWithName("walkLeft3"); _upFrameElements[0] = am.GetElementWithName("walkUp0"); _upFrameElements[1] = am.GetElementWithName("walkUp1"); _upFrameElements[2] = am.GetElementWithName("walkUp2"); _upFrameElements[3] = am.GetElementWithName("walkUp3"); _downFrameElements[0] = am.GetElementWithName("walkDown0"); _downFrameElements[1] = am.GetElementWithName("walkDown1"); _downFrameElements[2] = am.GetElementWithName("walkDown2"); _downFrameElements[3] = am.GetElementWithName("walkDown3"); ListenForUpdate(HandleUpdate); }
public VectorMatch(VectorMatch vm, int arg, int start, int count, VectorDirection dir) { Offset = vm.Offset + 4 * start;; Reg = vm.Reg; Start = start + vm.Start; Count = count; Upward = vm.Upward; calc = vm.calc; if (dir == VectorDirection.Unknown) { throw new OptimizationException("VectorMatch: Unknown vector direction"); } fpulines = new int[Count][]; for (int i = Start; i < count + Start; i++) { fpulines[i - Start] = ((UnwrappedElement)vectorizer.elements[i]).FpuLines; } arguments = new Element[count][]; Array.Copy(vm.arguments, start, arguments, 0, count); if (vm.pArguments != null) { pArguments = new Vector[vm.pArguments.Length + 1]; vm.pArguments.CopyTo(pArguments, 0); for (int i = 0; i < vm.pArguments.Length - 1; i++) { pArguments[i].Count = count; if (start > 0) { if (pArguments[i].Direction == VectorDirection.Up) { pArguments[i].Offset += 4 * start; } else if (pArguments[i].Direction == VectorDirection.Down) { pArguments[i].Offset -= 4 * start; } } } } else { pArguments = new Vector[1]; } pArguments[arg] = new Vector(arguments[0][arg].Offset, arguments[0][arg].Register, count, dir); }
private void HandleMovingInput() { VectorDirection[] directions = new VectorDirection[2]; directions[0] = VectorDirection.None; var index = 0; if (Input.GetKey(KeyCode.D)) { directions[index] = VectorDirection.Right; index++; } else if (Input.GetKey(KeyCode.A)) { directions[index] = VectorDirection.Left; index++; } if (Input.GetKey(KeyCode.W)) { directions[index] = VectorDirection.Up; index++; } else if (Input.GetKey(KeyCode.S)) { directions[index] = VectorDirection.Down; index++; } for (var i = 0; i < directions.Length; i++) { if (directions[i] != VectorDirection.Invalid) { OnMovingInput(directions[i]); } } foreach (KeyValuePair <KeyCode, KeyAction> subscribedKey in _subscribedKeys) { if (Input.GetKeyUp(subscribedKey.Key)) { subscribedKey.Value(); } } }
/// <summary> /// Removes a row or column vector in a matrix /// </summary> /// <param name="mat">The matrix</param> /// <param name="direction">The type of vector to remove (row or column)</param> /// <param name="removeIndex">The vector index to remove at</param> /// <returns>The matrix with an removed row/column at the specified index</returns> public static T[,] RemoveVector <T>(this T[,] mat, VectorDirection direction, int removeIndex) { MatrixDimensions d = mat.GetDimensions(); T[,] newMat; if (direction == VectorDirection.Column) { if (removeIndex > d.cols || removeIndex < 1) { throw new IndexOutOfRangeException("That column index does not exist in the matrix."); } newMat = new T[d.rows, d.cols - 1]; return(newMat.Apply((v, r, c) => { if (c < removeIndex) { return mat[r - 1, c - 1]; } else { return mat[r - 1, c]; } })); } else { if (removeIndex > d.rows || removeIndex < 1) { throw new IndexOutOfRangeException("That row index does not exist in the matrix."); } newMat = new T[d.rows - 1, d.cols]; return(newMat.Apply((v, r, c) => { if (r < removeIndex) { return mat[r - 1, c - 1]; } else { return mat[r, c - 1]; } })); } }
/// <summary> /// Converts a vector to a single-row/column matrix /// </summary> /// <param name="vector">The vector</param> /// <param name="shape">The resulting shape of the matrix (either horizontal or vertical)</param> /// <returns>The single-row/column matrix derived from the vector</returns> public static T[,] ExpandToMatrix <T>(this T[] vector, VectorDirection shape = VectorDirection.Vertical) { T[,] mat; if (shape == VectorDirection.Horizontal) { mat = new T[1, vector.Length]; for (int i = 0; i < vector.Length; i++) { mat[0, i] = vector[i]; } } else { mat = new T[vector.Length, 1]; for (int i = 0; i < vector.Length; i++) { mat[i, 0] = vector[i]; } } return(mat); }
public void Awake() { State = new MovementState(); //better to store transforms and references if we will call them often _transform = transform; _localScale = transform.localScale; _boxCollider = GetComponent <BoxCollider2D> (); // size of a collider multiplied by his scale, minus skinWidth in the corners var colliderWidth = _boxCollider.size.x * Mathf.Abs(transform.localScale.x) - (2 * SkinWidth); //calculated box colllider width divided by needed pieces(for 3 rays - 2 pieces) _horizontalDistanceBetweenRays = colliderWidth / (TotalVerticalRays - 1); var colliderHeight = _boxCollider.size.y * Mathf.Abs(transform.localScale.y) - (2 * SkinWidth); _verticalDistanceBetweenRays = colliderHeight / (TotalHorizontalRays - 1); _isFacingForward = transform.localScale.x > 0; _forwardVector = VectorDirection.Right; }
private bool HandleWall(ref Vector2 deltaMovement, float angle, bool isGoingRight) { var sign = isGoingRight ? 1 : -1; transform.Rotate(0, 0, sign * angle); if (transform.eulerAngles.z < 90) { _forwardVector = VectorDirection.Right; } else if (transform.eulerAngles.z < 180) { _forwardVector = VectorDirection.Down; } else if (transform.eulerAngles.z < 270) { _forwardVector = VectorDirection.Left; } else if (transform.eulerAngles.z < 360) { _forwardVector = VectorDirection.Up; } return(true); }
public Vector3 GetDirectionVector3(VectorDirection direction) { switch (direction) { // Gets the direction of the two vector points case VectorDirection.AToB: { var dx = _a.x - _b.x; var dy = _a.y - _b.y; var dz = _a.z - _b.z; return new Vector3(dx,dy,dz); } case VectorDirection.BToA: { var dx = _b.x - _a.x; var dy = _b.y - _a.y; var dz = _b.z - _a.z; return new Vector3(dx,dy,dz); } default: throw new Exception(); } }
public RegisterState(VectorDirection vd,byte b) { occupied=true; direction=vd; contains=b; }
private static VectorMatch[] ProcessSplit(VectorMatch vm, int arg) { int Offset = -1; int ExpectedOffset = -1; string Reg = ""; int VectorStart = 0; VectorDirection dir = VectorDirection.Unknown; ArrayList matches = new ArrayList(); for (int i = 0; i < vm.arguments.Length; i++) { if (i == 0 || Offset == -1) { Offset = vm.arguments[i][arg].Offset; Reg = vm.arguments[i][arg].Register; VectorStart = i; } else if (ExpectedOffset == -1) { if (vm.arguments[i][arg].Register == Reg && vm.arguments[i][arg].Offset == Offset + 4) { ExpectedOffset = vm.arguments[i][arg].Offset + 4; dir = VectorDirection.Up; } else if (vm.arguments[i][arg].Register == Reg && vm.arguments[i][arg].Offset == Offset - 4) { ExpectedOffset = vm.arguments[i][arg].Offset - 4; dir = VectorDirection.Down; } else if (vm.arguments[i][arg].Register == Reg && vm.arguments[i][arg].Offset == Offset) { ExpectedOffset = vm.arguments[i][arg].Offset; dir = VectorDirection.Static; } else { Offset = vm.arguments[i][arg].Offset; VectorStart = i; Reg = vm.arguments[i][arg].Register; ExpectedOffset = -1; } } else { if ((!(i - VectorStart == 4)) && vm.arguments[i][arg].Register == Reg && ExpectedOffset == vm.arguments[i][arg].Offset) { if (dir == VectorDirection.Up) { ExpectedOffset += 4; } else if (dir == VectorDirection.Down) { ExpectedOffset -= 4; } } else { matches.Add(new VectorMatch(vm, arg, VectorStart, i - VectorStart, dir)); Offset = vm.arguments[i][arg].Offset; VectorStart = i; Reg = vm.arguments[i][arg].Register; ExpectedOffset = -1; } } } if (Offset != -1 && ExpectedOffset != -1) { matches.Add(new VectorMatch(vm, arg, VectorStart, vm.arguments.Length - VectorStart, dir)); } return((VectorMatch[])matches.ToArray(typeof(VectorMatch))); }
/// <summary> /// Load vector /// </summary> /// <param name="value">Value of the load</param> /// <param name="direction">Direction by (X,Y or Z)</param> public LoadVector(double value, VectorDirection direction) { Value = value; Direction = direction; }
private bool HandleWall(ref Vector2 deltaMovement, float angle, bool isGoingRight) { var sign = isGoingRight ? 1 : -1; transform.Rotate (0, 0, sign * angle); if (transform.eulerAngles.z < 90 ) { _forwardVector = VectorDirection.Right; } else if (transform.eulerAngles.z < 180 ) { _forwardVector = VectorDirection.Down; } else if (transform.eulerAngles.z < 270 ) { _forwardVector = VectorDirection.Left; } else if (transform.eulerAngles.z < 360 ) { _forwardVector = VectorDirection.Up; } return true; }
/// <summary> /// Returns the number of rows/cols in the specified direction /// </summary> /// <param name="direction">The direction</param> /// <returns>The number of rows/cols in the specified direction</returns> public int InDirection(VectorDirection direction) { return(direction == VectorDirection.Row ? cols : rows); }
protected virtual void OnPlayerInput(VectorDirection direction) { if (State.MovingMode != MoveMode.Snapping && _isMovingEnabled != false && ( (direction == VectorDirection.Right && !_isFacingForward) || (direction == VectorDirection.Left && _isFacingForward) )) { Flip(); } _direction = direction; }
protected void HandleUpdate() { float dt = Time.deltaTime; if (Main.GameTime - _lastCycle > 10) { // spawn some new crew every 10 seconds spawnInventory(); //if(_crewSpawned < 20){ if (_crewMembers.Count < 10) // keep spawning crew so long as there arae not more than 10 currently out { spawnCrew(3); } _levelManager.scrambleDoors(); int totalMeltdownSegments = 20; // use 20 for shorter game play (about 3.3 minutes) // use 32 for shorter game play (about 5.3 minutes) if (_meltdownSegmentCount < totalMeltdownSegments) { float segmentWidth = 640 / totalMeltdownSegments; // draw another segment on the meltdown timer FSprite meltdownSegment = new FSprite("meltdownSegment"); meltdownSegment.width = segmentWidth; // calculate position float x = Futile.screen.halfWidth - (meltdownBar.width / 2) + 4 + (segmentWidth / 2); // 4 is to get the spacing right x += _meltdownSegmentCount * segmentWidth; meltdownSegment.SetPosition(x, 672); AddChild(meltdownSegment); _meltdownSegmentCount++; } else { GameOver(); } _lastCycle = Main.GameTime; } // handle input bool invKeyPressed = false; if (Input.GetKeyDown(KeyCode.Alpha1)) { invKeyPressed = true; _invNumSelected = 0; } else if (Input.GetKeyDown(KeyCode.Alpha2)) { invKeyPressed = true; _invNumSelected = 1; } else if (Input.GetKeyDown(KeyCode.Alpha3)) { invKeyPressed = true; _invNumSelected = 2; } else if (Input.GetKeyDown(KeyCode.Alpha4)) { invKeyPressed = true; _invNumSelected = 3; } else if (Input.GetKeyDown(KeyCode.Escape)) { invKeyPressed = false; _invNumSelected = -1; selectedInventory.isVisible = false; } if (invKeyPressed) { // so the user selected a valid inventory slot, // now make sure there is something in that slot if (_inventory[_invNumSelected] != null) { selectedInventory.SetPosition(positionForInventory(_invNumSelected)); selectedInventory.isVisible = true; } else { // they clicked on an empty inventory _invNumSelected = -1; } } // update crew member's movement direction //loop backwards so if we remove a crew member from the list, it won't cause problems for (int i = _crewMembers.Count - 1; i >= 0; i--) { Crew crewMember = _crewMembers[i]; VectorDirection currentDirection = crewMember.direction; Vector2 newCrewPosition = crewMember.calculateNewPosition(dt); if (!_levelManager.crewMemberIsPassingThruDoor(crewMember)) // passing through a door takes precidence { if (_levelManager.willObeyFloorTile(crewMember, newCrewPosition)) { } else if (_levelManager.willDirectCrewToDoor(crewMember)) // check if crew member is next to an open door, if so they will be directed to it { if (crewMember.direction != currentDirection) { // direction was updated, don't adjust position newCrewPosition = crewMember.GetPosition(); } } else if (!_levelManager.checkCrewHeadingOk(crewMember, newCrewPosition)) { // crew member heading into a wall, so heading was adjusted, don't update position newCrewPosition = crewMember.GetPosition(); } } // update crew member's position (having taken into account all previous checks) crewMember.SetPosition(newCrewPosition); // check if crew member is in the escape pod room int escapePodXMax = (64 * 7) - 32; int escapePodYMax = (64 * 3) - 32; if (newCrewPosition.x <= escapePodXMax && newCrewPosition.y <= escapePodYMax) { // you saved this crew member! FSoundManager.PlaySound("crewSaved1", 0.5f); Main.instance.crewSaved++; crewSavedLabel.text = "Crew Members Saved: " + Main.instance.crewSaved; _crewMembers.Remove(crewMember); crewMember.shouldDestroy = true; } } }
public ComputationResult(SparseArray <float> data, bool accumulator, VectorDirection direction = VectorDirection.Unassigned) { VectorData = data; Accumulator = accumulator; Direction = direction; }
public Vector(int offset,string reg,int count,VectorDirection dir) { Offset=offset; Register=reg; Count=count; Direction=dir; ; }
public VectorMatch(VectorMatch vm,int arg,int start,int count,VectorDirection dir) { Offset=vm.Offset+4*start; ; Reg=vm.Reg; Start=start+vm.Start; Count=count; Upward=vm.Upward; calc=vm.calc; if(dir==VectorDirection.Unknown) throw new OptimizationException("VectorMatch: Unknown vector direction"); fpulines=new int[Count][]; for(int i=Start;i<count+Start;i++) { fpulines[i-Start]=((UnwrappedElement)vectorizer.elements[i]).FpuLines; } arguments=new Element[count][]; Array.Copy(vm.arguments,start,arguments,0,count); if(vm.pArguments!=null) { pArguments=new Vector[vm.pArguments.Length+1]; vm.pArguments.CopyTo(pArguments,0); for(int i=0;i<vm.pArguments.Length-1;i++) { pArguments[i].Count=count; if(start>0) { if(pArguments[i].Direction==VectorDirection.Up) { pArguments[i].Offset+=4*start; } else if(pArguments[i].Direction==VectorDirection.Down) { pArguments[i].Offset-=4*start; } } } } else { pArguments=new Vector[1]; } pArguments[arg]=new Vector(arguments[0][arg].Offset,arguments[0][arg].Register,count,dir); }
public void Awake() { State = new MovementState (); //better to store transforms and references if we will call them often _transform = transform; _localScale = transform.localScale; _boxCollider = GetComponent<BoxCollider2D> (); // size of a collider multiplied by his scale, minus skinWidth in the corners var colliderWidth = _boxCollider.size.x * Mathf.Abs (transform.localScale.x) - (2 * SkinWidth); //calculated box colllider width divided by needed pieces(for 3 rays - 2 pieces) _horizontalDistanceBetweenRays = colliderWidth / (TotalVerticalRays - 1 ); var colliderHeight = _boxCollider.size.y * Mathf.Abs (transform.localScale.y) - (2 * SkinWidth); _verticalDistanceBetweenRays = colliderHeight / (TotalHorizontalRays - 1); _isFacingForward = transform.localScale.x > 0; _forwardVector = VectorDirection.Right; }
private void HandleMovingInput() { VectorDirection[] directions = new VectorDirection[2]; directions[0] = VectorDirection.None; var index = 0; if (Input.GetKey (KeyCode.D)) { directions[index] = VectorDirection.Right; index ++; } else if (Input.GetKey (KeyCode.A)) { directions[index] = VectorDirection.Left; index ++; } if (Input.GetKey (KeyCode.W)) { directions[index] = VectorDirection.Up; index ++; } else if (Input.GetKey (KeyCode.S)) { directions[index] = VectorDirection.Down; index ++; } for (var i = 0; i < directions.Length; i++) { if (directions[i] != VectorDirection.Invalid) { OnMovingInput(directions[i]); } } foreach(KeyValuePair<KeyCode, KeyAction> subscribedKey in _subscribedKeys ) { if (Input.GetKeyUp (subscribedKey.Key)) { subscribedKey.Value(); } } }