Tetris

This tutorial uses the October 2005 SDK version. Microsoft changed the functionality after this version and I never got around to updating the code.

Tetris is the game that everyone says to create_ for your first game. It’s got everything a basic game should have: user-interaction, time management, basic collision detection, etc. We’ve already learned everything about Managed DirectX that we need to know to create_ Tetris, it’s just a matter of implementing the code.

Tetris’ main idea is to align shapes. If you fill up a row completely, it disappears and you score. There are many different kinds of shapes but they all share the same basic functionality. Therefore, we will create_ a Shape class that all the different types of shapes will inherit from. Every Shape in Tetris is composed of 4 blocks, the basic unit of Tetris. We will create_ a Block class and each Shape will have an array of 4 Blocks.

This is the Block class. Each block has a position and a method to render itself. We will be using Sprites to render our game, so render the Block with Sprite.Draw. Notice that the Texture, Rectangle and BlockWidth variables are static. This is because every Block in Tetris shares these values so there is no point allocating the memory for new values.

using System;
using System.Collections;
using System.Drawing;
using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

namespace CUnit
{

/// <summary>Base Shape class</summary>
class Shape : ICloneable
{

public static Color[] s_Colors =

{

Color.Red, Color.ForestGreen, Color.SkyBlue, Color.Purple,
Color.Yellow, Color.Blue, Color.Orange

}

;
public enum ShapeType { Straight, Box, T, Zig, Zag, L, J };
protected Block[] m_blocks;
protected Color m_color;
protected int m_state;
protected ShapeType m_type;

/// <summary>Creates a new Shape</summary>
public Shape()

{

m_blocks = new Block[4];
m_state = 0;

// Make random color
Random random = new Random( DateTime.Now.Millisecond );
int index = random.Next( 0, s_Colors.Length );
m_color = s_Colors[index];

}

/// <summary>Moves each block down 1 unit</summary>
public void MoveDown()

{

foreach ( Block b in m_blocks )
{

b.Y += Block.BlockWidth;

}

}

/// <summary>Moves each block right 1 unit</summary>
public void MoveRight()

{

foreach ( Block b in m_blocks )
{

b.X += Block.BlockWidth;

}

}

/// <summary>Moves each block left 1 unit</summary>
public void MoveLeft()

{

foreach ( Block b in m_blocks )
{

b.X -= Block.BlockWidth;

}

}

/// <summary>Renders the shape</summary>
/// <param name=”sprite”>Sprite to render with</param>
public void Render( Sprite sprite )

{

foreach ( Block b in m_blocks )
{

b.Render( sprite, m_color );

}

}

/// <summary>Deactivates the blocks in a given row</summary>
/// <param name=”row”>Row to deactivate</param>
public void DeactivateBlocks( int row )

{

for ( int i = 0; i < 4; i++ )
{

if ( m_blocks[i].Y == row )
{

m_blocks[i].Active = false;

}

}

}

/// <summary>Determines if a Shape is blocked on the bottom.</summary>
/// <param name=”bottomBorder”>Bottom border</param>
/// <param name=”shapes”>Shapes that are settled</param>
/// <returns>true if the Shape is blocked, false otherwise.</returns>
public bool TouchingBottom( int bottomBorder, ArrayList shapes )

{

// See if any of the blocks are touching the bottom border
// or if they are touching the blocks of other shapes
foreach ( Block b1 in m_blocks )
{

if ( b1.Y >= bottomBorder )
{

return true;

}
foreach ( Shape s in shapes )
{

foreach ( Block b2 in s.Blocks )
{

if ( b2.Active && ( b1.X == b2.X ) && ( b1.Y + Block.BlockWidth == b2.Y ) )
{

return true;

}

}

}

}
return false;

}

/// <summary>Determines if a Shape is blocked on the right.</summary>
/// <param name=”bottomBorder”>Right border</param>
/// <param name=”shapes”>Shapes that are settled</param>
/// <returns>true if the Shape is blocked, false otherwise.</returns>
public bool TouchingRight( int rightBorder, ArrayList shapes )

{

// See if any of the blocks are touching the right border
// or if they are touching the blocks of other shapes
foreach ( Block b1 in m_blocks )
{

if ( b1.X >= rightBorder )
{

return true;

}
foreach ( Shape s in shapes )
{

foreach ( Block b2 in s.Blocks )
{

if ( b2.Active && ( b1.X + Block.BlockWidth == b2.X ) && ( b1.Y == b2.Y ) )
{

return true;

}

}

}

}
return false;

}

/// <summary>Determines if a Shape is blocked on the left.</summary>
/// <param name=”bottomBorder”>Left border</param>
/// <param name=”shapes”>Shapes that are settled</param>
/// <returns>true if the Shape is blocked, false otherwise.</returns>
public bool TouchingLeft( int leftBorder, ArrayList shapes )

{

// See if any of the blocks are touching the left border
// or if they are touching the blocks of other shapes
foreach ( Block b1 in m_blocks )
{

if ( b1.X <= leftBorder )
{

return true;

}
foreach ( Shape s in shapes )
{

foreach ( Block b2 in s.Blocks )
{

if ( b2.Active && ( b1.X == b2.X + Block.BlockWidth ) && ( b1.Y == b2.Y ) )
{

return true;

}

}

}

}
return false;

}

/// <summary>Determines if a Shape is intersecting another Shape or any of the borders.</summary>
/// <param name=”shapes”>Shapes that are settled</param>
/// <param name=”leftBorder”>Left border</param>
/// <param name=”rightBorder”>Right border</param>
/// <param name=”bottomBorder”>Bottom border</param>
/// <returns>true if the Shape is intersecting, false otherwise.</returns>
public bool IntersectingShapesOrBorders( ArrayList shapes, int leftBorder, int rightBorder, int bottomBorder )

{

foreach ( Block b1 in m_blocks )
{

// Intersecting border?
if ( b1.X < leftBorder || b1.X > rightBorder || b1.Y > bottomBorder )
{

return true;

}
// Intersecting another Shape?
foreach ( Shape s in shapes )
{

foreach ( Block b2 in s.Blocks )
{

if ( b2.Active && ( b1.X == b2.X ) && ( b1.Y == b2.Y ) )
{

return true;

}

}

}

}
return false;

}

/// <summary>Moves blocks down if a row has been deactivated</summary>
/// <param name=”row”>Deactivated row</param>
public void MoveBlocksAboveRowDown( int row )

{

for ( int i = 0; i < 4; i++ )
{

if ( m_blocks[i].Y < row )
{

m_blocks[i].Y += Block.BlockWidth;

}

}

}

/// <summary>Checks if all the blocks of the Shape are inactive</summary>
/// <returns>true if all the blocks are inactive, false otherwise</returns>
public bool AllInactive()

{

foreach ( Block b in m_blocks )
{

if ( b.Active )
{

return false;

}

}
return true;

}

/// <summary>Rotates the shape</summary>
public virtual void Rotate()

{

}

/// <summary>Gets and sets the Shape’s blocks.</summary>
public Block[] Blocks

{

get { return m_blocks; }
set { m_blocks = value; }

}

/// <summary>Gets and sets the Shape’s Color.</summary>
public Color Color

{

get { return m_color; }
set { m_color = value; }

}

/// <summary>Gets and sets the Shape’s rotation state.</summary>
public int State

{

get { return m_state; }
set { m_state = value; }

}

/// <summary>Clones the Shape.</summary>
public object Clone()

{
   Shape newShape = null;
   switch ( m_type )
   {
       case ShapeType.Straight:
           newShape = new ShapeStraight();
           break;
       case ShapeType.Box:
           newShape = new ShapeBox();
           break;
       case ShapeType.T:
           newShape = new ShapeT();
           break;
       case ShapeType.Zig:
           newShape = new ShapeZig();
           break;
       case ShapeType.Zag:
           newShape = new ShapeZag();
           break;
       case ShapeType.L:
           newShape = new ShapeL();
           break;
       case ShapeType.J:
           newShape = new ShapeJ();
           break;
       default:
           throw new Exception( “Invalid type.” );
   }
   Block[] blocks = new Block[4];
   for ( int i = 0; i < 4; i++ )
   {
       blocks[i] = (Block)m_blocks[i].Clone();
   }
   newShape.Blocks = blocks;
   newShape.Color = m_color;
   newShape.State = m_state;
   return newShape;
}

}

}

This is the base Shape class. It contains all the methods we need to manipulate the Shape. I’ll now give a brief overview of each method. Each Shape is assigned a random color as shown in the constructor using the Random class. The MoveDown, MoveRight, and MoveLeft methods do just what their names imply and are used to move the shapes with the keyboard. The Render method loops through all 4 of its Blocks and Renders them. We call the DeactivateBlocks method when a row has been completely filled up. This deactivates all the Blocks of a given row so they will no longer be rendered or accounted for.

The TouchingBottom, TouchingRight, and TouchingLeft methods are the collision detection methods. They determine when a Shape can no longer move down, right, or left. This will happen when another Shape is in the way or the Shape has reached one of the borders of the play board.

The IntersectingShapesOrBorders method is used to see if a Shape is currently intersecting a border or another Shape. When a Shape is rotated, some of its Blocks may be moved to a location where they intersect another Shape or are out of bounds, which is bad. Therefore, when we rotate a Shape, we will first Clone the Shape, rotate the clone and see if the clone is intersecting any Shapes or borders. If it isn’t then we can rotate the original Shape.

The MoveBlocksAboveRowDown is called when a row has been deactivated. This method moves all Blocks above a given row down one unit to take the place of the deactivated row. The AllInactive method checks if all of the Blocks in the Shape are not active. We will use this method to remove the Shape from our main ArrayList of Shapes, since we don’t need to keep around a Shape if all of its Blocks are inactive.

The Rotate method is dependant upon the type of Shape and will be implemented in the inherited Shapes. When we rotate, however, we need to keep track of the Shape’s current rotation state so we know how to make our next rotation. This is what the m_state variable keeps track of.

Finally, the Clone method is the implementation of the ICloneable interface. We use this method in conjuction with the IntersectingShapesOrBorders method as explained above.

These are the different types of Shapes found in Tetris. The only difference between them is the layout of their Blocks. Since they all have different Block layouts, they all need to be rotated differently. This took some quick pen-and-paper work to figure out the rotations.

The ShapeGenerator class is used to generate random Shapes. This is what determines which Shape we are currently playing with. All we do is use the Random class to pick a Shape.

This is the main control point of our game, Four Blocks of Fun. Since we’ll be plugging this into our GameApp class, it has the usual On*Device methods to handle resource allocation and deallocation. It also has methods to update_ and render the frame.

The main challenge of Tetris is the speed at which the Shapes fall. This will be determined with the m_shapeFallInterval variable. As the level increases, this value will decrease making the Shapes fall faster. We also have m_minFallInterval so the Shapes don’t keep falling faster and faster forever, which would be way too hard. Our game time will be managed by the Timer class that we wrote earlier.

In OnCreateDevice, we allocate our Block Texture, Sprite and game Font using the Font class we wrote earlier. In OnResetDevice, we create_ the off-screen surface to display the background, which we learned about in the previous tutorial. The OnLostDevice and OnDestroyDevice methods deallocate our game resources.

The Update method updates our game state. It updates the timer and see’s if enough time has passed to move the Shape down one unit. If enough time has passed, we first check to see if the Shape is touching anything on its bottom with Shape.TouchingBottom. If it isn’t touching anything we move the Shape down. If it is touching something, we first check if the game should be over. The game is over when the Shape is both touching a Shape below and touching the top of the screen. If the game isn’t over, it means that the Shape has landed. When the Shape lands, we increase the score with AddToScore, add the shape to our ArrayList of settled Shapes, and generate a new shape with the ShapeGenerator class. Once the Shape has been added to the ArrayList of settled Shapes, we check if any of the rows are complete with CheckRowCompletion.

The Render method simply renders everything to the screen. Since the FourBlocksOfFun class is plugged into the GameApp class, we don’t need to call Device.BeginScene or Device.EndScene, since those are called in GameApp.

The ProcessInput method processes user input. The Down, Left, and Right arrow keys move the Shape. When we move the Shape we check for collisions so we know if we can move the Shape in that direction. When we move down, there’s a chance that the Shape has landed so we do the same thing we did in the Update method: add the Shape to the settled shapes ArrayList and generate a new Shape. When we rotate the Shape with the Up key we have to check if the rotated Shape intersects anything. As explained earlier, we Clone the Shape and see if the clone intersects anything by calling Shape.IntersectingShapesOrBorders. If it isn’t we can rotate the Shape.

Since Shapes are generated at coordinates (0,0), the CenterShape method simply moves it right a few times so it starts in the center.

The CheckRowCompletion method is called everytime a Shape lands. To see if a row is complete, we loop through each row and count the number of blocks on the row. If this number is equal to the total number of columns in a row, the row is completely filled up. When a row is completely filled up, we add the row to an ArrayList so we can deactivate it later on. We don’t deactivate here because we are currently iterating through the rows and deactivating the row would mess up the iteration. We also increase a score multiplier. The score multiplier doubles for each row completed on a given Shape-landing. So for a single row completion, we would get ten points, while a completion of four rows would give us 80 points. Once we’ve found all the rows that need deactivation, we loop through each Shape and deactivate the Blocks on the given row with Shape.DeactivateBlocks. We also move all the higher Blocks down one unit with Shape.MoveBlocksAboveRowDown. Once we deactivate some Blocks, we need to check if all the Blocks of a given Shape are deactivated with Shape.AllInactive. If all the Blocks are inactive, there is no point in keeping the Shape around so we remove the Shape from our settled Shapes ArrayList.

Finally, the AddToScore method adds a given value to the player’s score. Every 100 points we increment the level and lower the shape fall interval so the blocks fall faster.

And there you have it: Tetri…I mean Four Blocks of Fun.