/** * This function creates the alignments for both sequences using the previous pointers array * Time Complexity: O(n) where n is the length of the larger sequence because it the best alignment * is as long as the length of the longest sequence * Space Complexity: O(n) where n is the length of the larger sequence as it creates a string as long as it */ void createAlignments(ref string[] alignment, ref directions[,] prev, ref GeneSequence sequenceA, ref GeneSequence sequenceB, ref int lengthOfSequenceA, ref int lengthOfSequenceB) { int rowIterator = lengthOfSequenceA, columnIterator = lengthOfSequenceB; StringBuilder first = new StringBuilder(), second = new StringBuilder(); while (rowIterator != 0 || columnIterator != 0) { if (prev[rowIterator, columnIterator] == directions.DIAGONAL) // match/sub { first.Insert(0, sequenceA.Sequence[rowIterator - 1]); second.Insert(0, sequenceB.Sequence[columnIterator - 1]); rowIterator--; columnIterator--; } else if (prev[rowIterator, columnIterator] == directions.LEFT) //insert { first.Insert(0, '-'); second.Insert(0, sequenceB.Sequence[columnIterator - 1]); columnIterator--; } else // delete { first.Insert(0, sequenceA.Sequence[rowIterator - 1]); second.Insert(0, '-'); rowIterator--; } } // Limiting the length of the string to 100 if it exceeds it alignment[0] = first.ToString().Substring(0, Math.Min(first.Length, 100)); alignment[1] = second.ToString().Substring(0, Math.Min(second.Length, 100)); }
/// <summary> /// Cookie constructor /// </summary> public Cookie(int idck, int xp, int yp, directions dir, string throwerName) { id = idck; x = xp; y = yp; direction = dir; thrower = throwerName; SendUpdate(); }
void Swipe(directions direction) { switch (direction) { case directions.UP: Events.OnSwipe(directions.UP); break; case directions.DOWN: Events.OnSwipe(directions.DOWN); break; case directions.RIGHT: Events.OnSwipe(directions.RIGHT); break; } }
public MazeElement GetSide(directions side) { switch (side) { case directions.north: return northWall; case directions.east: return eastWall; case directions.south: return southWall; case directions.west: return westWall; } return northWall; }
public void SetSide(directions side, MazeElement element) { switch (side) { case directions.north: northWall = element; break; case directions.east: eastWall = element; break; case directions.south: southWall = element; break; case directions.west: westWall = element; break; } }
public Tile(directions d, Waypoint wp, waypointTypes type) { this.direction = d; this.wp = wp; this.type = type; if (type.Equals(waypointTypes.StorageLocation) && !d.Equals(directions.EastNorthSouthWest)) { throw new ArgumentException("something went wrong with storage locations"); } if (d.Equals(directions.Invalid)) { throw new ArgumentException("direction invalid"); } if (wp == null) { throw new ArgumentException("wp is null"); } }
private void turnRight() { if (dir == directions.NORTH) { dir = directions.EAST; } else if (dir == directions.EAST) { dir = directions.SOUTH; } else if (dir == directions.SOUTH) { dir = directions.WEST; } else { dir = directions.NORTH; } }
public bool canBeAccessedFromDirection(directions dir) { switch (dir) { case directions.Top: return(!collidesFromAbove); case directions.Bottom: return(!collidesFromBelow); case directions.Left: return(!collidesFromLeft); case directions.Right: return(!collidesFromRight); default: return(true); } }
void Update() { //move if (Input.GetKeyDown(KeyCode.LeftArrow)) { dir = directions.LEFT; } if (Input.GetKeyDown(KeyCode.RightArrow)) { dir = directions.RIGHT; } if (Input.GetKeyDown(KeyCode.UpArrow)) { dir = directions.UP; } if (Input.GetKeyDown(KeyCode.DownArrow)) { dir = directions.DOWN; } }
public void buildStation(waypointTypes typeOfStation, int row, int column, directions d, List <Waypoint> bufferPaths, int activationOrderID) { switch (typeOfStation) { case waypointTypes.PickStation: buildPickStation(row, column, d, bufferPaths, activationOrderID); break; case waypointTypes.ReplenishmentStation: buildReplenishmentStation(row, column, d, bufferPaths, activationOrderID); break; case waypointTypes.Elevator: buildElevator(row, column, d, bufferPaths); break; default: throw new ArgumentException("should built station, but typeOfStations is: " + typeOfStation); } }
public void InputArrow(directions dir) { if (actualState != InputGameplayState.GAME) { return; } imgInput.sprite = GetIcon(dir); imgInput.gameObject.SetActive(true); inputs.Add(dir); if (dir != pattern[inputs.Count - 1]) { patternActual = 0; SFXManager.SharedInstance.PlaySFX(SFXType.SoundType.ERROR); PatternFail(); return; } if (inputs.Count == pattern.Count) { patternActual++; SFXManager.SharedInstance.PlaySFX(SFXType.SoundType.CORRECT); if (patternActual >= CantPatterns.Count) { actualState = InputGameplayState.END; HideGammeplayImages(); imgMSG.sprite = QuestionSprite; imgMSG.color = new Color(0, 155, 255); imgMSG.gameObject.SetActive(true); triviaGameplayManager.StartGame(); } else { PatternOK(); } } }
public void init(worldScript _myWorldScript, int x, int y, int w, int h, int _i) { myWorldScript = _myWorldScript; posX = x; posY = y; width = w; height = h; tFactor = 0f; id = _i; currentTile = myWorldScript.getTileXY(posX, posY); myDirection = getInitialDirection(currentTile, posX, posY); prevDirection = myDirection; switch (myDirection) { case directions.NORTH: transform.localPosition = new Vector3(transform.localPosition.x + 0.5f, transform.localPosition.y, transform.localPosition.z); nextPos = new Vector3((posX - (width / 2)) * 2, 1.5f, (((posY - 1) - (height / 2)) * -1) * 2); break; case directions.SOUTH: transform.localPosition = new Vector3(transform.localPosition.x - 0.5f, transform.localPosition.y, transform.localPosition.z); nextPos = new Vector3((posX - (width / 2)) * 2, 1.5f, (((posY + 1) - (height / 2)) * -1) * 2); break; case directions.WEST: transform.localPosition = new Vector3(transform.localPosition.x, transform.localPosition.y, transform.localPosition.z + 0.5f); nextPos = new Vector3(((posX - 1) - (width / 2)) * 2, 1.5f, ((posY - (height / 2)) * -1) * 2); break; case directions.EAST: transform.localPosition = new Vector3(transform.localPosition.x, transform.localPosition.y, transform.localPosition.z - 0.5f); nextPos = new Vector3(((posX + 1) - (width / 2)) * 2, 1.5f, ((posY - (height / 2)) * -1) * 2); break; } currentPos = transform.localPosition; prevPos = currentPos; }
//This is also used by the generateWalls class public static Vector3Int getVectorIncrement(directions direction) { switch (direction) { case directions.left: return(Vector3Int.left); case directions.right: return(Vector3Int.right); case directions.up: return(Vector3Int.up); case directions.down: return(Vector3Int.down); default: Debug.LogError("For some reason, this default clause was met! FIx this please"); return(Vector3Int.up); } }
public void move(directions dir, int len) { switch (dir) { case directions.down: setPosition(new Point(position.X, position.Y + len)); break; case directions.left: setPosition(new Point(position.X - len, position.Y)); break; case directions.right: setPosition(new Point(position.X + len, position.Y)); break; case directions.up: setPosition(new Point(position.X, position.Y - len)); break; } }
public void Update(IView view, directions playerDirection, directions shootDirection, bool shoot) { model.Player.direction = playerDirection; if (shoot) { model.Shoot(model.Player, shootDirection); shoot = false; } model.CheckCollisions(); model.MoveAfterCheck(); model.MakeExplosions(); model.MakePrizes(model.prizeCount); UpdateView(); view.Render(); }
directions getInitialDirection(tile currentTile, int x, int y) { if ( (Random.Range(0, 2) > 0) && ((myWorldScript.getTileXY(x, y - 1).whichType == tileTypes.BUILDING) || ((myWorldScript.getTileXY(x, y - 1).whichType == tileTypes.ROAD) && (myWorldScript.getTileXY(x, y - 1).whichRoadType == roadTypes.CROSS_VERTICAL))) ) { myDirection = directions.NORTH; } if ( (Random.Range(0, 2) > 0) && ((myWorldScript.getTileXY(x, y + 1).whichType == tileTypes.BUILDING) || ((myWorldScript.getTileXY(x, y + 1).whichType == tileTypes.ROAD) && (myWorldScript.getTileXY(x, y + 1).whichRoadType == roadTypes.CROSS_VERTICAL))) ) { myDirection = directions.SOUTH; } if ( (Random.Range(0, 2) > 0) && ((myWorldScript.getTileXY(x - 1, y).whichType == tileTypes.BUILDING) || ((myWorldScript.getTileXY(x - 1, y).whichType == tileTypes.ROAD) && (myWorldScript.getTileXY(x - 1, y).whichRoadType == roadTypes.CROSS_HORIZONTAL))) ) { myDirection = directions.WEST; } if ( (Random.Range(0, 2) > 0) && ((myWorldScript.getTileXY(x + 1, y).whichType == tileTypes.BUILDING) || ((myWorldScript.getTileXY(x + 1, y).whichType == tileTypes.ROAD) && (myWorldScript.getTileXY(x + 1, y).whichRoadType == roadTypes.CROSS_HORIZONTAL))) ) { myDirection = directions.EAST; } return(myDirection); }
public MenuScreen(ContentManager MyContent, SpriteBatch SpriteBatch) { myContent = MyContent; spriteBatch = SpriteBatch; myScreenMessage = ScreenMessages.none; myScreenType = ScreenTypes.MenuScreen; menuTexture = myContent.Load<Texture2D>("graphics\\MenuScreen\\MenuTexture"); font = myContent.Load<SpriteFont>("font\\menuButtonTextFont"); ButtonBorders = new Rectangle[2]; ButtonBorders[0] = new Rectangle(0,151,158,58); ButtonBorders[1] = new Rectangle(159, 151, 158, 58); Nyan = new Rectangle[4]; Nyan[0] = new Rectangle(2, 212, 66, 40); Nyan[1] = new Rectangle(69, 212, 66, 40); Nyan[2] = new Rectangle(2, 253, 66, 40); Nyan[3] = new Rectangle(69, 253, 66, 40); Enemy = new Rectangle[4]; Enemy[0] = new Rectangle(136, 212, 66, 40); Enemy[1] = new Rectangle(203, 212, 66, 40); Enemy[2] = new Rectangle(136, 253, 66, 40); Enemy[3] = new Rectangle(203, 253, 66, 40); Rainbow = new Rectangle[2]; Rainbow[0] = new Rectangle(269, 212, 66, 40); Rainbow[1] = new Rectangle(343, 212, 66, 40); actionFramePos = new Vector2(0, 175); currentDirection = directions.Right; selectedMenuItem = menuItems.PlayGame; PlayGameButtonString = "Play Game"; ExitGameButtonString = "Exit Game"; }
private Sprite GetIcon(directions dir) { if (dir == directions.UP) { return(UpIcon); } if (dir == directions.RIGHT) { return(RightIcon); } if (dir == directions.DOWN) { return(DownIcon); } if (dir == directions.LEFT) { return(LeftIcon); } Debug.LogWarning("Se ingreso un numero de icono invalido"); return(UpIcon); }
public void SetDirection(directions dir) { direction = dir; switch (direction) { case directions.Up: z = 0; break; case directions.Down: z = 180; break; case directions.Left: z = 270; break; case directions.Right: z = 90; break; } }
// METHODS public void seDéplacer(directions direction) { if (!Collision.Collided(direction)) // si le perso n'est pas en collision { this.Position = Vector2.Add(this.Position, new Vector2((float)direction * _vitesse, 0)); } switch (direction) { case directions.DROITE: _ligne = 1; break; case directions.GAUCHE: _ligne = 2; break; case directions.FACE: _ligne = 0; break; } }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////// Helper Functions ////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// /** * This function fills the first row and column with the cost of insert/delete for each one * Time Complexity: O(n+m) where n is the length of the first sequence and m is the length of the second sequence. * This is because it iterates over all letters in each sequence once * Space Complexity: O(1) because it passes the values by reference meaning it does not create a copy and * it does not create any variables that depend on the size of the input. */ void fillStartCells(ref int[,] values, ref directions[,] prev, int lengthA, int lengthB, bool banded) { for (int column = 0; column < lengthB + 1; column++) { if (banded == true && (column > distance)) { break; } values[0, column] = column * 5; prev[0, column] = directions.LEFT; } for (int row = 0; row < lengthA + 1; row++) { if (banded == true && (row > distance)) { break; } values[row, 0] = row * 5; prev[row, 0] = directions.TOP; } }
private static void GetNewDirection() { var inc = false; if (directionCounter == (2 * directionAmount)) { inc = true; directionCounter = 0; } if (directionSteps < directionAmount) { return; } switch (direction) { case directions.RIGHT: direction = directions.UP; break; case directions.LEFT: direction = directions.DOWN; break; case directions.UP: direction = directions.LEFT; break; case directions.DOWN: direction = directions.RIGHT; break; default: direction = directions.UP; break; } directionSteps = 0; if (inc) { directionAmount++; } }
void SShoot(int pos, directions richting) { int layer = 0; if (_direction[directions.Right] || _direction[directions.Left]) { layer = _switch.currentNum * 2; SwitchAllWeaponPositions(1); } else if (_direction[directions.Down]) { layer = 2; SwitchAllWeaponPositions(0); } else { SwitchAllWeaponPositions(0); } Shoot trigger = _triggers.triggers[_switch.currentNum]; //SwitchAllWeaponPositions(1);//sets the position at position 0 trigger.ShootWeapon(0, _directionVectors[richting]); }
private void OnCollisionEnter(Collision collision) { if (collision.gameObject.tag == "Enemy1") { if (dir == directions.Up) { dir = directions.Down; } else if (dir == directions.Down) { dir = directions.Up; } else if (dir == directions.Left) { dir = directions.Right; } else if (dir == directions.Right) { dir = directions.Left; } state = EnemyState.Moving; } }
/// <summary> /// Determines the opposite direction. /// </summary> public static Vector3 DetermineOppositeDirection(directions dir) { Vector3 resultingVector = Vector3.one; switch (dir) { case VectorDirection.directions.Up: resultingVector = Vector3.down; break; case VectorDirection.directions.Down: resultingVector = Vector3.up; break; case VectorDirection.directions.Right: resultingVector = Vector3.left; break; case VectorDirection.directions.Left: resultingVector = Vector3.right; break; case VectorDirection.directions.Forward: resultingVector = Vector3.back; break; case VectorDirection.directions.Back: resultingVector = Vector3.forward; break; case VectorDirection.directions.Equally: resultingVector = Vector3.zero; break; } return(resultingVector); }
public void RenderPlayer(Bitmap screen) { using (Graphics g = Graphics.FromImage(screen)) { switch (player.direction) { case directions.up: g.DrawImage(playerImages[0], new Rectangle(player.position_x, player.position_y, player.size_x, player.size_y)); casePlayerDirection = directions.up; break; case directions.down: g.DrawImage(playerImages[1], new Rectangle(player.position_x, player.position_y, player.size_x, player.size_y)); casePlayerDirection = directions.down; break; case directions.left: g.DrawImage(playerImages[2], new Rectangle(player.position_x, player.position_y, player.size_x, player.size_y)); casePlayerDirection = directions.left; break; case directions.right: g.DrawImage(playerImages[3], new Rectangle(player.position_x, player.position_y, player.size_x, player.size_y)); casePlayerDirection = directions.right; break; case directions.none: int i = (int)casePlayerDirection; g.DrawImage(playerImages[i], new Rectangle(player.position_x, player.position_y, player.size_x, player.size_y)); break; default: break; } } }
}; // invalid. private pwCell InDirection(directions dir) { switch (dir) { case directions.up: if (myPoint.y == 0) { return(null); } return(cells[(int)myPoint.x, (int)myPoint.y - 1]); case directions.right: if (myPoint.x == width - 1) { return(null); } return(cells[(int)myPoint.x + 1, (int)myPoint.y]); case directions.down: if (myPoint.y == height - 1) { return(null); } return(cells[(int)myPoint.x, (int)myPoint.y + 1]); case directions.left: if (myPoint.x == 0) { return(null); } return(cells[(int)myPoint.x - 1, (int)myPoint.y]); default: return(null); } }
bool turnIfMetBoundary() { //The boundary tle isn't blocking the way if (!boundaryTilemap.HasTile(currentPosition + getVectorIncrement(currentDirection))) { return(false); } //First finding all unblocked areas List <directions> allDirections = new List <directions>(new directions[] { directions.up, directions.down, directions.left, directions.right }); List <directions> availableDirections = new List <directions>(); foreach (directions direction in allDirections) { if (!boundaryTilemap.HasTile(currentPosition + getVectorIncrement(direction))) { availableDirections.Add(direction); } } //Picking any one of those free directions to turn to currentDirection = availableDirections[Random.Range(0, availableDirections.Count)]; return(true); }
private static void copyBorders() { // For all cells associated with a symmetry point, copy their association and borders. foreach (var cell in cells) { if (cell.centerPoint != invalid) { for (int k = 0; k < 4; k++) { if (cell.IsBorder((directions)k)) { Point opposite = Symmetry(cell.myPoint, cell.centerPoint); pwCell newCell = cells[(int)opposite.x, (int)opposite.y]; directions oppside = (directions)((k + 2) % 4); if (!newCell.IsBorder(oppside)) { Console.WriteLine($"Copying border from {cell.myPoint} to {opposite}."); newCell.SetBorder(oppside); } } } } } }
private static void associateDeadEnds() { // For each cell, if it's a dead end (borders on three sides), make sure that the association points out, so we can trim it. foreach (var cell in cells) { directions dirOut = directions.multi; if (cell.associates != directions.multi) { continue; // Already associated! } for (int k = 0; k < 4; k++) { if (cell.IsBorder((directions)k)) { continue; } pwCell newCell = cell.InDirection((directions)k); if (newCell.associates == (directions)((k + 2) % 4)) { continue; // if associates to this one, it might as well be a border! } if (dirOut != directions.multi) { dirOut = directions.multi; break; } dirOut = (directions)k; } if (dirOut != directions.multi) { cell.associates = dirOut; Console.WriteLine($"Associating dead-end cell at {cell.myPoint} to direction {dirOut}"); changesThisPass++; } } }
private void EnterDown(object sender, MouseEventArgs e) { MouseLastLocation = directions.down; }
private void EnterUp(object sender, MouseEventArgs e) { MouseLastLocation = directions.up; }
private void EnterRight(object sender, MouseEventArgs e) { MouseLastLocation = directions.right; }
/// <summary> /// 构造函数 /// </summary> /// <param name="x">敌人的x座标</param> /// <param name="y">敌人的y座标</param> /// <param name="life">敌人的生命</param> /// <param name="speed">敌人的速度</param> /// <param name="dir">敌人的方向</param> public Enemy(int x, int y, int type, directions dir) : base(x, y, SetLife(type), SetSpeed(type), imgEnemy1[0].Width, imgEnemy1[0].Height, dir) { this.type = type; BeBorn(); }
/// <summary> /// Reads the first two touche positions and handles them. /// </summary> //TODO: Move distance handling etc to Game Logic? private void HandlePinchInput() { float prevTouchDeltaMag = 0; float touchDeltaMag = 0; float deltaMagnitudeDifference = 0; Touch touchZero = Input.GetTouch(0); Touch touchOne = Input.GetTouch(1); Vector2 touchZeroPrevPos = touchZero.position - touchZero.deltaPosition; Vector2 touchOnePrevPos = touchOne.position - touchOne.deltaPosition; prevTouchDeltaMag = ( touchZeroPrevPos - touchOnePrevPos ).magnitude; touchDeltaMag = ( touchZero.position - touchOne.position ).magnitude; deltaMagnitudeDifference = prevTouchDeltaMag - touchDeltaMag; if (Input.touchCount >= 2) { if (touchZero.phase == TouchPhase.Ended || touchOne.phase == TouchPhase.Ended) { distance = 0; direction = directions.NONE; } } if (Mathf.Abs(distance) < 10) { distance += deltaMagnitudeDifference; } if (prevTouchDeltaMag > touchDeltaMag) { //Zoom Out (-) if (distance >= 10) { if (direction == directions.NONE || direction == directions.OUT) { distance += deltaMagnitudeDifference; AppManager.Instance.ZoomOut(Mathf.Abs(this.distance)); direction = directions.OUT; } } } else if (prevTouchDeltaMag < touchDeltaMag) { //Zoom In (+) if (distance <= -10) { if (direction == directions.NONE || direction == directions.IN) { distance += deltaMagnitudeDifference; AppManager.Instance.ZoomIn(Mathf.Abs(this.distance)); direction = directions.IN; } } } }
// Update is called once per frame void Update() { //foreach (KeyCode kcode in System.Enum.GetValues(typeof(KeyCode))) //{ // if (Input.GetKeyDown(kcode)) // text.text += ("" + kcode); //} if (Input.GetKeyDown(KeyCode.JoystickButton2)) { OnKeyPress(directions.up); } else if (Input.GetKeyDown(KeyCode.JoystickButton3)) { OnKeyPress(directions.right); } else if (Input.GetKeyDown(KeyCode.RightShift)) { OnKeyPress(directions.down); } else if (Input.GetKeyDown(KeyCode.Return)) { OnKeyPress(directions.left); } else if (Input.GetKeyDown(KeyCode.JoystickButton7)) { OnKeyPress(directions.click); } // text.text += Input.GetAxisRaw("Oculus_GearVR_LThumbstickX") != 0 ? "x: " + Input.GetAxis("Horizontal") : ""; // text.text += Input.GetAxisRaw("Oculus_GearVR_LThumbstickY") != 0 ? "y: " + Input.GetAxis("Vertical") : ""; //if (Input.GetKeyDown(KeyCode.JoystickButton2)) //{ // OnKeyPress(directions.up); //} //else if (Input.GetKeyDown(KeyCode.JoystickButton3)) //{ // OnKeyPress(directions.right); //} //else if (Input.GetKeyDown(KeyCode.JoystickButton0)) //{ // OnKeyPress(directions.left); //} //else if (Input.GetKeyDown(KeyCode.Joystick1Button1)) //{ // OnKeyPress(directions.down); //} //else if (Input.GetKeyDown(KeyCode.RightShift)) //{ // OnKeyPress(directions.click); //} //else if (Input.GetKeyDown(KeyCode.LeftShift)) //{ // OnKeyPress(directions.click); //} if (Input.GetKeyDown(KeyCode.UpArrow)) { OnKeyPress(directions.up); } else if (Input.GetKeyDown(KeyCode.RightArrow)) { OnKeyPress(directions.right); } else if (Input.GetKeyDown(KeyCode.LeftArrow)) { OnKeyPress(directions.left); } else if (Input.GetKeyDown(KeyCode.DownArrow)) { OnKeyPress(directions.down); } else if (Input.GetKeyDown(KeyCode.Space)) { OnKeyPress(directions.click); } if ((prevDirection != directions.right || joystickTimer.ElapsedMilliseconds > 200f) && Input.GetAxisRaw("Oculus_GearVR_LThumbstickX") == 1) { joystickTimer.Reset(); joystickTimer.Start(); prevDirection = directions.right; OnKeyPress(directions.right); } else if ((prevDirection != directions.left || joystickTimer.ElapsedMilliseconds > 200f) && Input.GetAxisRaw("Oculus_GearVR_LThumbstickX") == -1) { joystickTimer.Reset(); joystickTimer.Start(); prevDirection = directions.left; OnKeyPress(directions.left); } else if ((prevDirection != directions.down || joystickTimer.ElapsedMilliseconds > 200f) && Input.GetAxisRaw("Oculus_GearVR_LThumbstickY") == -1) { joystickTimer.Reset(); joystickTimer.Start(); prevDirection = directions.down; OnKeyPress(directions.down); } else if ((prevDirection != directions.up || joystickTimer.ElapsedMilliseconds > 200f) && Input.GetAxisRaw("Oculus_GearVR_LThumbstickY") == 1) { joystickTimer.Reset(); joystickTimer.Start(); prevDirection = directions.up; OnKeyPress(directions.up); } }
private directions setFacing(directions a) { return(this.facing = a); }
void ChangeDirection(directions _d) { currentDirection = _d; print (currentDirection); }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////// Banded Algorithm ////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// /** * This function performs the banded algorithm on the two sequences using dynamic programming to come up with * the best alignment for both. The band is set to whatever the distance is. Currently it is d = 3 which makes the * bandwidth equals 2d+1 = 7. * Time Complexity: O(n+m) where n is the length of the first sequence and m is the length of the second sequence. This * is because the algorithm iterates over a specific number of cells for each row and column. As we don't * care about constants, the time would depend on the length of sequence A and B. Meaning each time * the array size is increased by a row or a column, we have to compute those bandwidth number of cells * again, so it is O(n+m). * Space Complexity: O(nm) where n is the length of the first sequence and m is the length of the second sequence. This * is because the algorithm creates an array of n x m */ void bandedAlgorithm(ref int score, ref string[] alignment, ref GeneSequence sequenceA, ref GeneSequence sequenceB) { // Limiting the lengths of the sequences to the max characters to align int lengthOfSequenceA = Math.Min(sequenceA.Sequence.Length, MaxCharactersToAlign); int lengthOfSequenceB = Math.Min(sequenceB.Sequence.Length, MaxCharactersToAlign); // Create two arrays to hold the intermediate values and the alignment details int[,] values = new int[lengthOfSequenceA + 1, lengthOfSequenceB + 1]; directions[,] prev = new directions[lengthOfSequenceA + 1, lengthOfSequenceB + 1]; // first fill first row and column with cost of inserts/deletes fillStartCells(ref values, ref prev, lengthOfSequenceA, lengthOfSequenceB, true); int columnStart = 1; bool alignmentFound = false; int row = 1; int column = columnStart; // Now iterate through the rest of the cells filling out the min value for each for (row = 1; row < lengthOfSequenceA + 1; row++) { for (column = columnStart; column < lengthOfSequenceB + 1; column++) { if ((distance + row) < column) { break; } // Compute values for each direction int costOfTop_Delete = values[row - 1, column] + 5; if ((distance + row) == column) { costOfTop_Delete = int.MaxValue; } int costOfLeft_Insert = values[row, column - 1] + 5; if ((distance + column) == row) { costOfLeft_Insert = int.MaxValue; } // Compute cost of moving from diagonal depending on whether the letters match int costOfMovingFromDiagonal = (sequenceA.Sequence[row - 1] == sequenceB.Sequence[column - 1]) ? -3 : 1; int costOfDiagonal = values[row - 1, column - 1] + costOfMovingFromDiagonal; // value of cell would be the minimum cost out of the three directions int costOfMin = Math.Min(costOfDiagonal, Math.Min(costOfLeft_Insert, costOfTop_Delete)); values[row, column] = costOfMin; // Store the direction if (costOfMin == costOfDiagonal) { prev[row, column] = directions.DIAGONAL; } else if (costOfMin == costOfLeft_Insert) { prev[row, column] = directions.LEFT; } else { prev[row, column] = directions.TOP; } if (column == lengthOfSequenceB && row == lengthOfSequenceA) alignmentFound = true; } if (row > distance) columnStart++; } // score would be value of the last cell if (alignmentFound) { score = values[lengthOfSequenceA, lengthOfSequenceB]; // Create the alignments createAlignments(ref alignment, ref prev, ref sequenceA, ref sequenceB, ref lengthOfSequenceA, ref lengthOfSequenceB); } else { score = int.MaxValue; alignment[0] = "No Alignment Possible"; alignment[1] = "No Alignment Possible"; } }
/// <summary> /// Add a cookie to the jar /// </summary> public static void AddCookie(int x, int y, directions dir, int id, string throwerName) { cookies.Add(new Cookie(id, x, y, dir, throwerName)); }
public void SwapSlot(int slot, directions dir) { int row = SlotNumberToRow(slot); int col = SlotNumberToCol(slot); int newrow=0; int newcol=0; switch (dir) { case directions.up: newrow = row - 1; newcol = col; break; case directions.right: newrow = row; newcol = col + 1; break; case directions.down: newrow = row + 1; newcol = col; break; case directions.left: newrow = row; newcol = col - 1; break; } int newslot = RowColToSlot(newrow, newcol); slots[newslot] = slots[slot]; slots[slot] = 0; }
///////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////// Unrestricted Algorithm //////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////// /** * This function performs the unrestricted algorithm on the two sequences using dynamic programming to come up with * the best alignment for both. * Time Complexity: O(nm) where n is the length of the first sequence and m is the length of the second sequence. This * is because the algorithm iterates over all cells in the array of n x m * Space Complexity: O(nm) where n is the length of the first sequence and m is the length of the second sequence. This * is because the algorithm creates an array of n x m */ void unrestrictedAlgorithm (ref int score, ref string[] alignment, ref GeneSequence sequenceA, ref GeneSequence sequenceB) { // Limiting the lengths of the sequences to the max characters to align int lengthOfSequenceA = Math.Min(sequenceA.Sequence.Length, MaxCharactersToAlign); int lengthOfSequenceB = Math.Min(sequenceB.Sequence.Length, MaxCharactersToAlign); // Create two arrays to hold the intermediate values and the alignment details int[,] values = new int[lengthOfSequenceA + 1, lengthOfSequenceB + 1]; directions[,] prev = new directions[lengthOfSequenceA + 1, lengthOfSequenceB + 1]; // first fill first row and column with cost of inserts/deletes fillStartCells(ref values, ref prev, lengthOfSequenceA, lengthOfSequenceB, false); // Now iterate through the rest of the cells filling out the min value for each for (int row = 1; row < lengthOfSequenceA + 1; row++) { for (int column = 1; column < lengthOfSequenceB + 1; column++) { // Compute values for each direction int costOfTop_Delete = values[row - 1, column] + 5; int costOfLeft_Insert = values[row, column - 1] + 5; // Compute cost of moving from diagonal depending on whether the letters match int costOfMovingFromDiagonal = (sequenceA.Sequence[row - 1] == sequenceB.Sequence[column - 1]) ? -3 : 1; int costOfDiagonal = values[row - 1, column - 1] + costOfMovingFromDiagonal; // value of cell would be the minimum cost out of the three directions int costOfMin = Math.Min(costOfTop_Delete, Math.Min(costOfLeft_Insert, costOfDiagonal)); values[row, column] = costOfMin; // Store the direction if (costOfMin == costOfDiagonal) { prev[row, column] = directions.DIAGONAL; } else if (costOfMin == costOfLeft_Insert) { prev[row, column] = directions.LEFT; } else { prev[row, column] = directions.TOP; } } } // score would be value of the last cell score = values[lengthOfSequenceA, lengthOfSequenceB]; // Create the alignments createAlignments(ref alignment, ref prev, ref sequenceA, ref sequenceB, ref lengthOfSequenceA, ref lengthOfSequenceB); }
private void EnterLeft(object sender, MouseEventArgs e) { MouseLastLocation = directions.left; }
public HumanPlayer(int id, string username, int xPos, int yPos, int score, directions facing) : base(id, username, xPos, yPos, score) { this.facing = facing; }
public P2Tank(int x, int y, int speed, int life, directions dir) : base(x, y, life, speed, dir, imgTank2) { }
void Walk(directions direction) { Vector3 newPosition = new Vector3(this.transform.position.x, this.transform.position.y, this.transform.position.z); directions rotation = CheckRotation(); switch (direction) { case directions.up: if (rotation == directions.north) { newPosition.z += Variables.unityUnit; } else if (rotation == directions.south) { newPosition.z -= Variables.unityUnit; } else if (rotation == directions.west) { newPosition.x -= Variables.unityUnit; } else { newPosition.x += Variables.unityUnit; } break; case directions.down: if (rotation == directions.north) { newPosition.z -= Variables.unityUnit; } else if (rotation == directions.south) { newPosition.z += Variables.unityUnit; } else if (rotation == directions.west) { newPosition.x += Variables.unityUnit; } else { newPosition.x -= Variables.unityUnit; } break; case directions.left: if (rotation == directions.north) { newPosition.x -= Variables.unityUnit; } else if (rotation == directions.south) { newPosition.x += Variables.unityUnit; } else if (rotation == directions.west) { newPosition.z -= Variables.unityUnit; } else { newPosition.z += Variables.unityUnit; } break; case directions.right: if (rotation == directions.north) { newPosition.x += Variables.unityUnit; } else if (rotation == directions.south) { newPosition.x -= Variables.unityUnit; } else if (rotation == directions.west) { newPosition.z += Variables.unityUnit; } else { newPosition.z -= Variables.unityUnit; } break; default: break; } if (newPosition.x <= ((Variables.mapXWidth - 1) * Variables.unityUnit) && newPosition.z <= ((Variables.mapYWidth - 1) * Variables.unityUnit)) { if (newPosition.x < 0 || newPosition.z < 0) { return; } } foreach (var item in gameMap.ListOfFloorTiles) { FloorTile floorTile = item.GetComponent <FloorTile>(); if (floorTile.position == new Vector3(newPosition.x, 0, newPosition.z)) { floorTile.hasWalked = true; this.transform.position = newPosition; Debug.Log("Moved to position: " + newPosition); } } }
public Position randomDirection() { bool[] ar = new bool[] {false,false,false,false}; Position Chosen; Chosen.x = 0; Chosen.y = 0; while( !ar[0] || !ar[1] || !ar[2] || !ar[3] ) { int random = UnityEngine.Random.Range(0,4);; if ( random == 0 && !ar[0]) { ar[0] = true; if (current.x > 0 && maze[current.x - 1,current.y].visited == false) { aDirection = directions.Up; Chosen.x--; return Chosen; } } else if (random == 1 && !ar[1] ) { ar[1] = true; if ( current.y < ( sizeOfMap - 1) && maze[current.x,current.y + 1].visited == false) { aDirection = directions.Right; Chosen.y++; return Chosen; } } else if (random == 2 && !ar[2] ) { ar[2] = true; if (current.x <(sizeOfMap - 1) && maze[current.x + 1,current.y].visited == false) { aDirection = directions.Down; Chosen.x++; return Chosen; } } else if (random == 3 && !ar[3] ) { ar[3] = true; if (current.y > 0 && maze[current.x,current.y - 1].visited == false) { aDirection = directions.Left; Chosen.y--; return Chosen; } } } Chosen.x = -1; Chosen.y = -1; return Chosen; }
private void ChangeCurPanel(directions d) { if (ftueActive || uiController.disableButtons || uiController.isSleeping) { return; } if (d == directions.up) { if (curPanel.isBack || (curPanel.upNeighbor.isVideo && videoOptions.mediaController.disableVideoOptions)) { return; } else if (curPanel.upNeighbor != null && curPanel.upNeighbor.isVideo) { ShowVideoOptions(); indicator.SetActive(false); prevPanel = curPanel; curPanel = curPanel.upNeighbor ?? curPanel; moveIndicator(); } else if (prevPanel == null) { curPanel = curPanel.upNeighbor ?? curPanel; if (viewPort.activeInHierarchy && indicator.transform.localPosition.y > -84 && viewPort.transform.localPosition.y > 50) { var curPos = viewPort.transform.localPosition; viewPort.transform.localPosition = new Vector3(curPos.x, curPos.y - 131, curPos.z); } moveIndicator(); } } else if (d == directions.right) { if (curPanel.isVideo) { curPanel = curPanel.rightNeighbor ?? curPanel; moveIndicator(); } else if (prevPanel != null) { backIndicator.SetActive(false); indicator.SetActive(true); curPanel = prevPanel; prevPanel = null; } else { curPanel = curPanel.rightNeighbor ?? curPanel; moveIndicator(); } } else if (d == directions.down) { if (curPanel.isBack) { return; } else if (prevPanel != null) { HideOptions(); vidOptionsIndicator.SetActive(false); indicator.SetActive(true); curPanel = prevPanel; prevPanel = null; } else { curPanel = curPanel.downNeighbor ?? curPanel; if (viewPort.activeInHierarchy && indicator.transform.localPosition.y < -200 && viewPort.transform.localPosition.y < 280) { var curPos = viewPort.transform.localPosition; viewPort.transform.localPosition = new Vector3(curPos.x, curPos.y + 131, curPos.z); } moveIndicator(); } } else if (d == directions.left) { if (curPanel.isVideo) { curPanel = curPanel.leftNeighbor ?? curPanel; moveIndicator(); } else if (curPanel.leftNeighbor != null && curPanel.leftNeighbor.isBack) { backIndicator.SetActive(true); indicator.SetActive(false); prevPanel = curPanel; curPanel = curPanel.leftNeighbor ?? curPanel; } else { curPanel = curPanel.leftNeighbor ?? curPanel; moveIndicator(); } } else if (d == directions.click) { indicator.SetActive(false); if (curPanel != null && !curPanel.isVideo) { prevPanel = null; } curPanel.thisButton.onClick.Invoke(); backIndicator.SetActive(false); } }
// Used to generate a random direction and check to see if it's a valid direction private Position randomDirection() { bool[] ar = new bool[] {false,false,false,false}; Position Chosen; Chosen.x = 0; Chosen.y = 0; while( !ar[0] || !ar[1] || !ar[2] || !ar[3] ) // Checks to see if any walls can be broken down { int random = UnityEngine.Random.Range(0,4);; if ( random == 0 && !ar[0]) { ar[0] = true; if (current.x > 0 && maze[current.x - 1,current.y].visited == false) // Checks if we aren't at top border { aDirection = directions.Up; Chosen.x--; return Chosen; } } else if (random == 1 && !ar[1] ) // Checks if we aren't at right border { ar[1] = true; if ( current.y < ( sizeOfMap - 1) && maze[current.x,current.y + 1].visited == false) { aDirection = directions.Right; Chosen.y++; return Chosen; } } else if (random == 2 && !ar[2] ) // Checks if we aren't at bottom border { ar[2] = true; if (current.x <(sizeOfMap - 1) && maze[current.x + 1,current.y].visited == false) { aDirection = directions.Down; Chosen.x++; return Chosen; } } else if (random == 3 && !ar[3] ) // Checks if we aren't at the left border { ar[3] = true; if (current.y > 0 && maze[current.x,current.y - 1].visited == false) { aDirection = directions.Left; Chosen.y--; return Chosen; } } } Chosen.x = -1; // Can't move anywhere so we must go back Chosen.y = -1; return Chosen; }
void Update() { //move if (Input.GetKeyDown(KeyCode.LeftArrow)) dir = directions.LEFT; if (Input.GetKeyDown(KeyCode.RightArrow)) dir = directions.RIGHT; if (Input.GetKeyDown(KeyCode.UpArrow)) dir = directions.UP; if (Input.GetKeyDown(KeyCode.DownArrow)) dir = directions.DOWN; }
void SwitchDirection() { if (currentDirection == directions.Right) currentDirection = directions.Left; else if (currentDirection == directions.Left) currentDirection = directions.Right; }