public Game(int width, int height, ImmutableArray<Piece> pieces, bool pieceFixed = false) { this.width = width; this.pieces = CentralizedPieces(pieces, width); movingPiece = this.pieces.GetCurrentPiece(); this.pieces = new Pieces(this.pieces.PiecesArray,this.pieces.CurrentPiece + 1); gameField = CreateGameField(height); score = 0; this.pieceFixed = pieceFixed; }
public Game(ImmutableArray<ImmutableSortedSet<Cell>> gameField, Pieces pieces, Piece movingPiece, int score, int width, bool pieceFixed = false) { this.gameField = gameField; this.pieces = pieces; this.score = score; this.movingPiece = movingPiece; this.width = width; this.pieceFixed = pieceFixed; }
public static Panel Draw(Piece piece) { var panel = new Panel(); for (int x = 0; x < piece.W; x++) { for (int y = 0; y < piece.H; y++) { if (piece.Squares[x, y] == 1) { var a = 10+x + Square.size * x; var b = 10 + y + Square.size * y; panel.Controls.Add(new Square(new Point(a, b))); } } } return panel; }
//Returns false if the whole piece is off the board, returns true otherwise public bool checkOnBoard(Piece piece) { foreach(Block block in piece.Blocks) { if (checkOnBoard(block.Position)) return true; } return false; }
//used when the currentPiece lands and locks out and the currentPiece is switched to the next one public void changeCurrentPiece() { currentPiece = upcomingPieces.Dequeue(); canHold = true; }
//makes the hold piece the current piece if there is no hold piece, otherwise switches the hold piece and the current piece public void changeHoldPiece() { if (canHold) { if (holdPiece == null) { holdPiece = currentPiece; removeCurrentPiece(); changeCurrentPiece(); } else { Piece pieceValue = holdPiece; holdPiece = currentPiece; removeCurrentPiece(); currentPiece = new Piece(pieceValue.PieceType); } canHold = false; } }
private bool kick(Piece piece) { bool value = piece.canMoveUp(); if (value) piece.moveUp(); if (isValid(piece)) { blocks = piece.blocks; return true; } else { bool value1 = piece.canMoveUp(); if (value1) piece.moveUp(); if (isValid(piece)) { blocks = piece.blocks; return true; } else { if (value1) piece.fall(); } if (value) piece.fall(); } value = piece.canMoveLeft(); if (value) piece.moveLeft(); if (isValid(piece)) { blocks = piece.blocks; return true; } else { bool value1 = piece.canMoveLeft(); if (value1) piece.moveLeft(); if (isValid(piece)) { blocks = piece.blocks; return true; } else { if (value1) piece.moveRight(); } if (value) piece.moveRight(); } value = piece.canMoveRight(); if (value) piece.moveRight(); if (isValid(piece)) { blocks = piece.blocks; return true; } else { bool value1 = piece.canMoveRight(); if (value1) piece.moveRight(); if (isValid(piece)) { blocks = piece.blocks; return true; } else { if (value1) piece.moveLeft(); } if (value) piece.moveLeft(); } return false; }
private void rotateZ() { Piece piece = new Piece(pieceType); Block[] blocks = piece.blocks; switch (rotationState) { case RotationState.One: blocks[0].Position = boundingSquare[0, 0]; blocks[1].Position = boundingSquare[1, 0]; blocks[2].Position = boundingSquare[1, 1]; blocks[3].Position = boundingSquare[2, 1]; checkRotateValid(piece); break; case RotationState.Two: blocks[0].Position = boundingSquare[2, 0]; blocks[1].Position = boundingSquare[2, 1]; blocks[2].Position = boundingSquare[1, 1]; blocks[3].Position = boundingSquare[1, 2]; checkRotateValid(piece); break; case RotationState.Three: blocks[0].Position = boundingSquare[2, 2]; blocks[1].Position = boundingSquare[1, 2]; blocks[2].Position = boundingSquare[1, 1]; blocks[3].Position = boundingSquare[0, 1]; checkRotateValid(piece); break; case RotationState.Four: blocks[0].Position = boundingSquare[0, 2]; blocks[1].Position = boundingSquare[0, 1]; blocks[2].Position = boundingSquare[1, 1]; blocks[3].Position = boundingSquare[1, 0]; checkRotateValid(piece); break; } }
private void checkRotateValid(Piece piece) { if (isValid(piece)) { this.blocks = piece.blocks; } else { bool kicked = kick(piece); if (!kicked) { StackTrace stackTrace = new StackTrace(); if (stackTrace.GetFrame(2).GetMethod().Name == "rotateRight") rotationState = (RotationState)((mod((int)rotationState - 1, 4))); else rotationState = (RotationState)((mod((int)rotationState + 1, 4))); } } }
private bool isValid(Piece piece) { foreach (Block block in piece.Blocks) { if (!TetrisGame.PlayerBoard.checkOnBoard(block.Position) || TetrisGame.PlayerBoard.BoardState[block.Position.X, block.Position.Y] != null) return false; } return true; }
bool GetPointState(int x, int y, Piece piece) { return piece.Now[x, y]; }
public void AddNewPiece() { CurrentPiece = new Piece(); }
public void AddNewPiece(Block[] blocks) { CurrentPiece = new Piece(blocks); }
//Deletes the currentpiece private void removeCurrentPiece() { for (int counter = 0; counter < currentPiece.Blocks.Length; counter++ ) { boardState[currentPiece.Blocks[counter].Position.X, currentPiece.Blocks[counter].Position.Y] = null; currentPiece.Blocks[counter] = null; } currentPiece = null; }
private ImmutableArray<ImmutableSortedSet<Cell>> CreateGameField(int height, Piece movingPiece = null) { if (movingPiece == null) movingPiece = this.movingPiece != null ? this.movingPiece : pieces.GetCurrentPiece(); ImmutableSortedSet<Cell>[] mutableGameField = new ImmutableSortedSet<Cell>[height]; for (int i = 0; i < mutableGameField.Length;i++) mutableGameField[i] = ImmutableSortedSet<Cell>.Empty; foreach (var point in movingPiece.Cells) { mutableGameField[point.Y] = mutableGameField[point.Y].Add(point); } return ImmutableArray.Create(mutableGameField); }
private Pieces CentralizedPieces(ImmutableArray<Piece> piecesArray,int width) { Piece[] centralizedPieces = new Piece[piecesArray.Length]; for (int i = 0; i < centralizedPieces.Length; i++) { int xShift = (width - (piecesArray[i].MaxX - piecesArray[i].MinX + 1)) / 2 - piecesArray[i].MinX; int yShift = piecesArray[i].MinY; Cell[] centralizedCells = new Cell[piecesArray[i].Cells.Length]; for (int j = 0; j < centralizedCells.Length; j++) { centralizedCells[j] = piecesArray[i].Cells[j].MoveTowards(xShift).MoveDown(-yShift); } centralizedPieces[i] = new Piece(centralizedCells,piecesArray[i].FindCentralCellIndex()); } return new Pieces(ImmutableArray.Create(centralizedPieces)); }
public Game MovePiece(Piece movedPiece) { if (movedPiece == null) return PlaceNextPiece(); int minY = movedPiece.MinY > movingPiece.MinY ? movingPiece.MinY : movedPiece.MinY; int maxY = movedPiece.MaxY > movingPiece.MaxY ? movedPiece.MaxY : movingPiece.MaxY; ImmutableSortedSet<Cell>[] changedArrays = GameFieldMutablePart(minY, maxY); //movedPiece, //int[] mutableLinesLength = linesLength.Select(z => z).ToArray(); int movingYDiff = movingPiece.MinY - minY; foreach (var cell in movingPiece.Cells) {//?DSLKFJDSNLFSKDJLSEFDKL/// int y = cell.Y - movingPiece.MinY + movingYDiff; //mutableLinesLength[cell.Y]--; /*if (mutableLinesLength[cell.Y] == 0) changedArrays[y] = null; else*/ changedArrays[y] = changedArrays[y].Remove(cell);// = null; } bool wrongPlacement = false; int movedYDiff = movedPiece.MinY - minY; foreach (var cell in movedPiece.Cells) { int y = cell.Y - movedPiece.MinY + movedYDiff; //if (mutableLinesLength[cell.Y] == 0) // changedArrays[y] = new Cell[width]; if (changedArrays[y].Contains(cell))// != null) { wrongPlacement = true; break; } changedArrays[y] = changedArrays[y].Add(cell);//[cell.X] = cell; //mutableLinesLength[cell.Y]++; } if (wrongPlacement) { return PlaceNextPiece(); } return new Game(ReworkedGameField(changedArrays,minY,maxY),pieces, movedPiece,score,width); }
static void Main() { int level = 0; int linesCount = 0; int score = 0; int playfieldWidth = 16; int playfieldHeigth = 30; field = new byte[playfieldHeigth, playfieldWidth, 2]; RemoveScrollBars(playfieldWidth * 2, playfieldHeigth); //Remove the scroll bars Console.Title = "Tetris"; Piece currentPiece = new Piece(playfieldWidth / 2 - 2); //Create the first piece while (true) { Console.Clear(); //Clear the field DrawField(); //Redraw the field; currentPiece.Draw(); //Draw the piece while (Console.KeyAvailable) //Move if possible the piece left/right or rotate if a proper key is pressed { ConsoleKeyInfo pressedKey = Console.ReadKey(true); currentPiece.Clean(); currentPiece.Move(pressedKey); currentPiece.Draw(); }; currentPiece.Move(); //Check if possible and move down or stop moving if (currentPiece.isFinal) //If stop moving check lines and score { score += 4; for ( int i = 0; i < field.GetLength(0); i++) { int line = 1; for (int j = 1; j < field.GetLength(1) - 1; j++) { line *= field[i, j, 0]; } if (line != 0) { linesCount++; level = level < 5 ? linesCount / 20 : 5; score += 40; for (int c = 0; c < field.GetLength(1); c++) { for (int r = i; r > 0; r--) { field[r, c, 0] = field[r - 1, c, 0]; field[r, c, 1] = field[r - 1, c, 1]; } field[0, c, 0] = 0; field[0, c, 1] = 0; } } } currentPiece = new Piece(playfieldWidth / 2 - 2); } DrawInfo(level, score, linesCount); //Draw info if (GameOver()) //Check if game over { DrawStringOnPosition(field.GetLength(1) - 6, field.GetLength(0) / 2, "!!!GAME OVER!!!", ConsoleColor.Red); Console.WriteLine(); break; } Console.Beep(); //Play sound Thread.Sleep(600 - 100 * level); //Slow the program } }
private static Texture2D fullTextureForPiece(Piece piece) { Texture2D texture = null; if (piece == null) return TetrisGame.emptyTexture; else { switch (piece.PieceType) { case BlockType.I: texture = TetrisGame.IblockTexture; break; case BlockType.J: texture = TetrisGame.JblockTexture; break; case BlockType.L: texture = TetrisGame.LblockTexture; break; case BlockType.O: texture = TetrisGame.OblockTexture; break; case BlockType.S: texture = TetrisGame.SblockTexture; break; case BlockType.T: texture = TetrisGame.TblockTexture; break; case BlockType.Z: texture = TetrisGame.ZblockTexture; break; } return texture; } }
public object Clone() { Piece p; p = new Piece(this.m_data, this.m_type, new TransFormation(this.m_trans), this.m_color); return p; switch (Type) { case PieceType.P1: p = Piece.P1; break; default: p = Piece.P1; break; } p.SetPosition(X, Y); switch (m_trans.Rotation) { case 90: p.Rotate(Direction.Right); break; case 180: p.Rotate(Direction.Right); p.Rotate(Direction.Right); break; case 270: p.Rotate(Direction.Left); break; } return p; }
private static void InitStocked() { m_index = 0; //shuffle Piece[] pieces = new Piece[] { Piece.P1, Piece.P2, Piece.P1, Piece.P2, Piece.P1, Piece.P2, Piece.P1 }; new Random().Shuffle(pieces); m_Stocked.Clear(); m_Stocked.AddRange(pieces); }
void timer_Tick(object sender, EventArgs e) { if(!falling) { falling = true; currentPiece = pieces[new Random().Next(pieces.Count)]; currentPosition = new Point(painter.SceneSize.Width / 2 - currentPiece.Size.Width / 2, 0); if(!CheckCollision()) { painter.DrawPiece(currentPiece, currentPosition, true); } else { GameOver(); } } else { if(!CheckCollision()) { Move(); } else { if(goWhere == Direction.Down) { falling = false; SetOccupied(); Eliminate(); } } } }
public void DrawPiece(Piece piece, Point position, bool state) { for(int i = 0; i < piece.Size.Width; i++) { for(int j = 0; j < piece.Size.Height; j++) { if(piece.Now[i, j]) DrawGrid(i + position.X, j + position.Y, state); } } }