game.cs

这个程序是基于c＃平台的俄罗斯方框游戏。拿来共享。要求加分哦！

								// Current block can't move to the left.
								// Sets the "canMove" flag to "false".
								canMove = false;
							}
						}
					}

					// Checks if the block can be moved to the left.
					if (canMove)
					{
						// Block can be moved to the left.
						// Moves the block to the left.
						currentBlock.Left--;
					}
				}
			}
			else
			{
				// The block is not to be moved to the left (it is to be moved to the right).
				// Checks if the block is not already at the most right of the playing field.
				if ((currentBlock.Left + currentBlock.Width) < PlayingFieldWidth)
				{
					// Block is not at the most right of the playing field.
					// Checks if the current block can move to the right.
					// COLLISION DETECTION
					for(int i = 0; i < currentBlock.Width; i++)
					{
						for(int j = 0; j < currentBlock.Height; j++)
						{
							int fx, fy;
							fx = currentBlock.Left + i;
							fy = (currentBlock.Top + 1) + j;
							if ((currentBlock.Shape[i, j].Filled == true) && (pile[(fx + 1), fy].Filled == true))
							{
								// Current block can't move to the right.
								// Sets the "canMove" flag to "false".
								canMove = false;
							}
						}
					}

					// Checks if the block can be moved to the right.
					if (canMove)
					{
						// Block can be moved to the right.
						// Moves the block to the right.
						currentBlock.Left++;
					}
				}
			}
		}

		/// <summary>
		/// Method that draws the pile in a surface.
		/// </summary>
		/// <param name="drawingSurface">The graphics surface where the pile will be drawn.</param>
		public void DrawPile(Graphics drawingSurface)
		{
			// Runs through the playing field Width.
			for (int i = 0; i < (PlayingFieldWidth + 1); i++)
			{
				// Runs through the playing field Height.
				for (int j = 0; j < (PlayingFieldHeight + 1); j++)
				{
					// Checks if the current brick of the pile is set to be solid.
					if (pile[i, j].Filled == true)
					{
						// Current brick of the pile is set to be solid.
						// Creates a rectangle in the right position of this brick.
						Rectangle rect = new Rectangle(i * BlockImageWidth, (j - 1) * BlockImageHeight, BlockImageWidth, BlockImageHeight);
						// Draws the block image in the just created rectangle.
						drawingSurface.DrawImage(pile[i, j].BrickImage, rect);
					}
				}
			}
		}

		/// <summary>
		/// Method that draws the current block in a surface.
		/// </summary>
		/// <param name="drawingSurface">The graphics surface where the current block will be drawn.</param>
		public void DrawCurrentBlock(Graphics drawingSurface)
		{
			// Checks if there is a current block.
			if (currentBlock != null)
			{
				// There is a current block.
				// Draws the current block in the drawing surface.
				currentBlock.Draw(drawingSurface);
			}
		}

		/// <summary>
		/// Method that draws the next block in a surface.
		/// </summary>
		/// <param name="drawingSurface">The graphics surface where the current block will be drawn.</param>
		public void DrawNextBlock(Graphics drawingSurface)
		{
			// Checks if there is a next block.
			if (nextBlock != null)
			{
				// There is a next block.
				// Saves the current Left and Top properties of the next block.
				short currentLeft = nextBlock.Left;
				short currentTop = nextBlock.Top;

				// Changes the current Left and Top properties of the next block, so they can be shown
				// in the center of a drawing surface that has a size of 6x6 blocks.
				nextBlock.Left = (short)((6 - nextBlock.Width) / 2);
				nextBlock.Top = (short)((6 - nextBlock.Height) / 2);

				// Draws the next block in the drawing surface.
				nextBlock.Draw(drawingSurface);

				// Retrieves the previously saved Left and Top properties, and put them back in the next block.
				nextBlock.Left = currentLeft;
				nextBlock.Top = currentTop;
			}
		}

		/// <summary>
		/// Private method that clears the current game pile.
		/// </summary>
		private void ClearPile()
		{
			// Runs through the playing field Width.
			for(int i = 0; i < (PlayingFieldWidth + 1); i++)
			{
				// Runs through the playing field Height.
				for(int j = 0; j < (PlayingFieldHeight + 1); j++)
				{
					// Clears the current brick of the pile.
					pile[i, j].Filled = false;
				}
			}
		}

		/// <summary>
		/// Private method that creates a new current block by getting it from the next block, 
		/// and creates a new random next block.
		/// </summary>
		private void CreateNewBlock()
		{
			// Checks if there is a next block.
			if (this.nextBlock != null)
			{
				// There is a next block.
				// Sets the current block to the next block.
				currentBlock = nextBlock;
			}
			else
			{
				// There isn't a next block.
				// Sets the current block as a new random block.
				currentBlock = new Block();
			}

			// Sets the next block as a new random block.
			nextBlock = new Block();
		}

		/// <summary>
		/// Private method that moves the current block to the game pile.
		/// While moving the block to the pile, it checks if there are complete lines, and count them, in
		/// order to update the score, the lines and the level. It also checks for game over.
		/// </summary>
		private void MoveBlockToPile()
		{
			// Runs through the current block Width.
			for(int i = 0; i < currentBlock.Width; i++)
			{
				// Runs through the current block Height.
				for(int j = 0; j < currentBlock.Height; j++)
				{
					// Converts the current brick position the a playing field position.
					int fx, fy;
					fx = currentBlock.Left + i;
					fy = currentBlock.Top + j;
					// Checks if the current brick is solid.
					if (currentBlock.Shape[i, j].Filled == true)
					{
						// The current brick is solid.
						// Moves the current brick to the pile.
						pile[fx, fy].Filled = true;
						pile[fx, fy].BrickImage = currentBlock.Shape[i, j].BrickImage;
					}
				}
			}

			// Checks for complete lines.
			CheckForLines();

			// Checks for game over.
			CheckForGameOver();
		}

		/// <summary>
		/// Private method that checks the pile for complete lines.
		/// </summary>
		/// <returns>The number of found lines.</returns>
		private int CheckForLines()
		{
			// Creates a variable that will hold the number of lines found.
			int numLines = 0;
			// Creates a variable that will hold the number of the complete lines found.
			int[] completeLines = new int[PlayingFieldHeight];

			// Runs through the playing field lines.
			for (int j = PlayingFieldHeight; j > 0; j--)
			{
				// Checks if there is a complete line.
				bool fullLine = true;

				for (int i = 0; i < PlayingFieldWidth; i++)
				{
					if (pile[i, j].Filled == false)
					{
						fullLine = false;
						break;
					}
				}

				// Checks if there was a complete line.
				if (fullLine)
				{
					// There was a complete line.
					// Increases the number of complete lines found.
					numLines++;
					// Pauses the game so no block will come down while clearing the complete line.
					this.GameState = GameState.Paused;
					// Holds the number of the complete line found.
					completeLines[numLines] = j;
					// Sets the game state to "Running" again, to release the game.
					this.GameState = GameState.Running;
				}
			}

			// Checks if there were any complete lines.
			if (numLines > 0)
			{
				// There were complete lines.
				// Runs through all the complete lines, and clears them.
				for(int i = 1; i <= numLines; i++)
				{
					// Clear a complete line.
					ClearLine((completeLines[i] + (i - 1)));
				}
				// Updates the game score, lines and level.
				score += 5 * (numLines * (numLines + 1));
				lines += numLines;
				level = (short)((lines / LevelEveryLines) + startLevel);
			}

			// Returns the number of complete lines.
			return numLines;
		}

		/// <summary>
		/// Private method that checks the pile for game over.
		/// </summary>
		private void CheckForGameOver()
		{
			// Checks if the top of the current block is on the top of the pile.
			if (currentBlock.Top == 1)
			{
				// Current block is on the top the the pile.
				// Sets the game state to "Over".
				this.GameState = GameState.Over;
			}
		}

		/// <summary>
		/// Private method that clears a line from the pile.
		/// </summary>
		/// <param name="lineNumber">The number of the line to be cleared.</param>
		private void ClearLine(int lineNumber)
		{
			// Runs through all the lines, from the line to be cleared up.
			for (int j = lineNumber; j > 0; j--)
			{
				// Runs through all the bricks in one line.
				for (int i = 0; i < PlayingFieldWidth; i++)
				{
					// Move the current brick down.
					pile[i, j] = pile[i, (j - 1)];
				}
			}

			// Runs through the top line bricks.
			for (int i = 0; i < PlayingFieldWidth; i++)
			{
				// Sets the current brick to empty.
				pile[i, 0].Filled = false;
			}
		}
	}
}