The Submission Process

1. The Draft

2. Moderator Review

3. Peer Review

Content Guidelines

Attachments

Content Types

• The Teaser Paragraph must include an adequate description of the link
• The link must be to a content source for which you do not have permission to repost
• This content source may be an individual article or a page that lists individual articles - so long as those articles all fall under the same Article Category chosen for the link
• Authorship must be given to the actual content owner. This can be a website or individual

Authorship

Foreign Language Submissions

License

Terms and Conditions

Questions? Comments? Feedback?

Introduction

__kernel void imagingTest(__read_only  image2d_t srcImg,
					   __write_only image2d_t dstImg)
{
  const sampler_t smp = CLK_NORMALIZED_COORDS_FALSE | //Natural coordinates
	CLK_ADDRESS_CLAMP_TO_EDGE | //Clamp to zeros
	CLK_FILTER_LINEAR;
  int2 coord = (int2)(get_global_id(0), get_global_id(1));

  uint4 bgra = read_imageui(srcImg, smp, coord); //The byte order is BGRA

  float4 bgrafloat = convert_float4(bgra) / 255.0f; //Convert to normalized [0..1] float

  //Convert RGB to luminance (make the image grayscale).
  float luminance =  sqrt(0.241f * bgrafloat.z * bgrafloat.z + 0.691f * bgrafloat.y * bgrafloat.y + 0.068f * bgrafloat.x * bgrafloat.x);
  bgra.x = bgra.y = bgra.z = (uint) (luminance * 255.0f);

  bgra.w = 255;

  write_imageui(dstImg, coord, bgra);
}

Namespaces Used

using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Runtime.InteropServices;
using OpenCL.Net;

Error handling

private void CheckErr(Cl.ErrorCode err, string name)
{
	if (err != Cl.ErrorCode.Success) {
		Console.WriteLine("ERROR: " + name + " (" + err.ToString() + ")");
	}
}

private void ContextNotify(string errInfo, byte[] data, IntPtr cb, IntPtr userData) {
	Console.WriteLine("OpenCL Notification: " + errInfo);
}

Setting Up

private Cl.Context _context;
private Cl.Device _device;

private void Setup ()
{
	Cl.ErrorCode error;
	Cl.Platform[] platforms = Cl.GetPlatformIDs (out error);
	List<Cl.Device> devicesList = new List<Cl.Device> ();
  
	CheckErr (error, "Cl.GetPlatformIDs");
  
	foreach (Cl.Platform platform in platforms) {
		string platformName = Cl.GetPlatformInfo (platform, Cl.PlatformInfo.Name, out error).ToString ();
		Console.WriteLine ("Platform: " + platformName);
		CheckErr (error, "Cl.GetPlatformInfo");

		//We will be looking only for GPU devices
		foreach (Cl.Device device in Cl.GetDeviceIDs(platform, Cl.DeviceType.Gpu, out error)) {
			CheckErr (error, "Cl.GetDeviceIDs");
			Console.WriteLine ("Device: " + device.ToString ());
			devicesList.Add (device);
		}
	}
  
	if (devicesList.Count <= 0) {
		Console.WriteLine ("No devices found.");
		return;
	}
  
	_device = devicesList[0];
  
	if (Cl.GetDeviceInfo(_device, Cl.DeviceInfo.ImageSupport, out error).CastTo<Cl.Bool>() == Cl.Bool.False)
	{
		Console.WriteLine("No image support.");
		return;
	}

	_context = Cl.CreateContext(null, 1, new[] { _device }, ContextNotify, IntPtr.Zero, out error);	//Second parameter is amount of devices
	CheckErr(error, "Cl.CreateContext");
}

The Image Processing Part

public void ImagingTest (string inputImagePath, string outputImagePath)
{
	Cl.ErrorCode error;

	//Load and compile kernel source code.
	string programPath = Environment.CurrentDirectory + "/../../ImagingTest.cl";	//The path to the source file may vary
  
	if (!System.IO.File.Exists (programPath)) {
		Console.WriteLine ("Program doesn't exist at path " + programPath);
		return;
	}
  
	string programSource = System.IO.File.ReadAllText (programPath);
  
	using (Cl.Program program = Cl.CreateProgramWithSource(_context, 1, new[] { programSource }, null, out error)) {
		CheckErr(error, "Cl.CreateProgramWithSource");

		//Compile kernel source
		error = Cl.BuildProgram (program, 1, new[] { _device }, string.Empty, null, IntPtr.Zero);
		CheckErr(error, "Cl.BuildProgram");

		//Check for any compilation errors
		if (Cl.GetProgramBuildInfo (program, _device, Cl.ProgramBuildInfo.Status, out error).CastTo<Cl.BuildStatus>()
			!= Cl.BuildStatus.Success) {
			CheckErr(error, "Cl.GetProgramBuildInfo");
			Console.WriteLine("Cl.GetProgramBuildInfo != Success");
			Console.WriteLine(Cl.GetProgramBuildInfo(program, _device, Cl.ProgramBuildInfo.Log, out error));
			return;
		}

		//Create the required kernel (entry function)
		Cl.Kernel kernel = Cl.CreateKernel(program, "imagingTest", out error);
		CheckErr(error, "Cl.CreateKernel");
	  
		int intPtrSize = 0;
		intPtrSize = Marshal.SizeOf(typeof(IntPtr));

		//Image's RGBA data converted to an unmanaged[] array
		byte[] inputByteArray;
		//OpenCL memory buffer that will keep our image's byte[] data.
		Cl.Mem inputImage2DBuffer;

		Cl.ImageFormat clImageFormat = new Cl.ImageFormat(Cl.ChannelOrder.RGBA, Cl.ChannelType.Unsigned_Int8);

		int inputImgWidth, inputImgHeight;
	  
		int inputImgBytesSize;

		int inputImgStride;

		//Try loading the input image
		using (FileStream imageFileStream = new FileStream(inputImagePath, FileMode.Open) ) {
			System.Drawing.Image inputImage = System.Drawing.Image.FromStream( imageFileStream );
		  
			if (inputImage == null) {
				Console.WriteLine("Unable to load input image");
				return;
			}
		  
			inputImgWidth = inputImage.Width;
			inputImgHeight = inputImage.Height;
		  
			System.Drawing.Bitmap bmpImage = new System.Drawing.Bitmap(inputImage);

			//Get raw pixel data of the bitmap
			//The format should match the format of clImageFormat
			BitmapData bitmapData = bmpImage.LockBits( new Rectangle(0, 0, bmpImage.Width, bmpImage.Height),
													  ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);//inputImage.PixelFormat);

			inputImgStride = bitmapData.Stride;
			inputImgBytesSize = bitmapData.Stride * bitmapData.Height;
		  
			//Copy the raw bitmap data to an unmanaged byte[] array
			inputByteArray = new byte[inputImgBytesSize];
			Marshal.Copy(bitmapData.Scan0, inputByteArray, 0, inputImgBytesSize);

			//Allocate OpenCL image memory buffer
			inputImage2DBuffer = Cl.CreateImage2D(_context, Cl.MemFlags.CopyHostPtr | Cl.MemFlags.ReadOnly, clImageFormat,
												(IntPtr)bitmapData.Width, (IntPtr)bitmapData.Height,
												(IntPtr)0, inputByteArray, out error);
			CheckErr(error, "Cl.CreateImage2D input");
		}

		//Unmanaged output image's raw RGBA byte[] array
		byte[] outputByteArray = new byte[inputImgBytesSize];

		//Allocate OpenCL image memory buffer
		Cl.Mem outputImage2DBuffer = Cl.CreateImage2D(_context, Cl.MemFlags.CopyHostPtr | Cl.MemFlags.WriteOnly, clImageFormat,
													  (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)0, outputByteArray, out error);
		CheckErr(error, "Cl.CreateImage2D output");

		//Pass the memory buffers to our kernel function
		error = Cl.SetKernelArg(kernel, 0, (IntPtr)intPtrSize, inputImage2DBuffer);
		error |= Cl.SetKernelArg(kernel, 1, (IntPtr)intPtrSize, outputImage2DBuffer);
		CheckErr(error, "Cl.SetKernelArg");
	  
		//Create a command queue, where all of the commands for execution will be added
		Cl.CommandQueue cmdQueue = Cl.CreateCommandQueue(_context, _device, (Cl.CommandQueueProperties)0, out error);
		CheckErr(error, "Cl.CreateCommandQueue");

		Cl.Event clevent;

		//Copy input image from the host to the GPU.
		IntPtr[] originPtr = new IntPtr[] { (IntPtr)0, (IntPtr)0, (IntPtr)0 };	//x, y, z
		IntPtr[] regionPtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 };	//x, y, z
		IntPtr[] workGroupSizePtr = new IntPtr[] { (IntPtr)inputImgWidth, (IntPtr)inputImgHeight, (IntPtr)1 };
		error = Cl.EnqueueWriteImage(cmdQueue, inputImage2DBuffer, Cl.Bool.True, originPtr, regionPtr, (IntPtr)0, (IntPtr)0, inputByteArray, 0, null, out clevent);
		CheckErr(error, "Cl.EnqueueWriteImage");

		//Execute our kernel (OpenCL code)
		error = Cl.EnqueueNDRangeKernel(cmdQueue, kernel, 2, null, workGroupSizePtr, null, 0, null, out clevent);
		CheckErr(error, "Cl.EnqueueNDRangeKernel");

		//Wait for completion of all calculations on the GPU.
		error = Cl.Finish(cmdQueue);
		CheckErr(error, "Cl.Finish");

		//Read the processed image from GPU to raw RGBA data byte[] array
		error = Cl.EnqueueReadImage(cmdQueue, outputImage2DBuffer, Cl.Bool.True, originPtr, regionPtr,
									(IntPtr)0, (IntPtr)0, outputByteArray, 0, null, out clevent);
		CheckErr(error, "Cl.clEnqueueReadImage");

		//Clean up memory
		Cl.ReleaseKernel(kernel);
		Cl.ReleaseCommandQueue(cmdQueue);
	  
		Cl.ReleaseMemObject(inputImage2DBuffer);
		Cl.ReleaseMemObject(outputImage2DBuffer);

		//Get a pointer to our unmanaged output byte[] array
		GCHandle pinnedOutputArray = GCHandle.Alloc(outputByteArray, GCHandleType.Pinned);
		IntPtr outputBmpPointer = pinnedOutputArray.AddrOfPinnedObject();

		//Create a new bitmap with processed data and save it to a file.
		Bitmap outputBitmap = new Bitmap(inputImgWidth, inputImgHeight, inputImgStride, PixelFormat.Format32bppArgb, outputBmpPointer);
	  
		outputBitmap.Save(outputImagePath, System.Drawing.Imaging.ImageFormat.Png);

		pinnedOutputArray.Free();
	}
}

Introduction

TDD is one of the most popular software development techniques. I like this technology in general, and we employ it to some extent. The main thing is not to run to extremes when using it. One shouldn't fully rely on it alone forgetting other methods of software quality enhancement. In this article, I will show you how the static code analysis methodology can be used by programmers using TDD to additionally secure themselves against errors.

TDD is wonderful

int A() {
            int x;
            return x; //Err
}

int B() {
            static int x;
            return x; //Ok
}

TDD is wonderful but don't go mad about it

TEST(SharedMemoryTest, MultipleThreads) {
            ....
            int threadcounts[] = { 1, kNumThreads };
            for (size_t i = 0;
                                     i < sizeof(threadcounts) / sizeof(threadcounts); i++) {
            ....
}

bool Test()
{
            char *buf = new char[10];
            FooFoo(buf);
            bool ok = memcmp(buf, "1234567890", sizeof(buf)) == 0;
            delete [] buf;
            return ok;
}

VTK_THREAD_RETURN_TYPE vtkTestCondVarThread( void* arg )
{
....
            if ( td )                                                                                                            <<<---
            {
                        ....
            }
            else
            {
                        cout << "No thread data!&#092;n";
                        cout << "            Thread " << ( threadId + 1 )
                                                 << " of " << threadCount << " exiting.&#092;n";

                        -- td->NumberOfWorkers;            <<<---

                        cout.flush();
            }
            ...
}

Conclusions

This is my summary of the article:

1. TDD is a wonderful technology. You should spend some time on studying it and start using it in your work. If the classic TDD doesn't suit you, don't abandon this methodology right away. Perhaps you will be able to use it if you consider using it a bit differently or at a higher abstraction level.

2. Don't go mad about it. Ideal methodologies don't exist. Tests check far not all the code in practice, and tests themselves are also error-prone. Use other testing methods: load testing, static code analysis and dynamic code analysis.

Introduction

Simply put, 2D animation is movement and transformation of objects on the screen in two dimensions. A good example of 2D animation is classic cartoons – multiple pictures of Mickey Mouse or Donald Duck alternating over time and producing the effect of moving objects. The modern 2D animation software allows creating animation much easier though, without making oodles of frames.

Frames and Keyframes

Just like with classic animation, computer 2D animation also consists of frames. Frame is a single picture of an object illustrating certain position, size and other properties of that object. Adjacent frames are slightly different from each other, so when the animation is played at the full speed – usually 24 frames per second – the effect of motion appears. This is similar to cartoons and movies.

But in computer animation you typically don’t have to draw each and every frame manually. Most of 2D animation software allows you to set up keyframes – frames that specify intermediate positions of an object. The motion of the object between these keyframes is built by the software automatically. So you end up with creating keyframes only, while the animation tool calculates and builds the rest of frames automatically. This process is called interpolation.

Curve Animation

The motion between two keyframes can be different – accelerating, slowing down, steady or even all of these in one move. The simplest way to specify how exactly one keyframe should translate to another is curves. A curve defines how a specific parameter of an object, such as a coordinate or a scale should vary over time.

Let’s take a look at a simple animation example made in one of 2D animation programs – GameDev Animation Studio. We want to make a ball move from up to down and then bounce back.

Basically, this means the vertical coordinate of the object, or simply the Y-coordinate should change from zero (the top of the screen) to the maximum value that corresponds to the bottom of the screen. Then the ball “bounces”, i.e. its form gets distorted in the vertical direction and restored again. After that, the ball moves up, which means the Y-coordinate should decrease back to zero. Also note, that due to gravity, the ball moves down with acceleration, while the backward movement must be decelerating. This is mirrored in the slope of the curve: a sharper slope means faster movement and vise versa.

Position Curve

So the curve describing vertical movement of the ball looks as follows:

As you see, the curve here gradually develops from zero to its maximum, and then, after the peak, it goes back to zero again. The highest value of the curve corresponds to the moment the ball hits the ground – this happens in the 30th frame on the timeline. After that moment, the ball starts moving up.

Zoom Curve

When the ball is just to hit the ground, it starts deforming. Indeed, the ball is elastic, so it kinda must deform. This animation can be done with another curve – the zoom curve. We’ll change the vertical scale (Y-scale) of the ball to reflect the way it gets distorted during the hit.

Above is the Y-scale zoom curve. As you see, prior the 29th frame the curve is at its maximum. This corresponds to the non-deformed ball falling down. In 29th, the curve goes down, and the ball’s image is zoomed down along the vertical axis. Then, after the curve passes the “hit-the-ground” point in 31st frame, the image is zoomed up to normal, so the curve goes up again to its maximum.

Note, that the higher the zoom factor is, the more elastic the ball will look. Thus, experimenting with curves in 2D animation tools is an easy way to find the most spectacular and satisfying animation effects. On the other hand, the classic animation approach would require you to discard all the work already done and start from scratch if you decided to change something.

Adding Details to Animation

Obviously, the ball just moving up and down doesn’t look too realistic, that is why we need a shadow. We should place a shadow picture beneath the ball and use curves to make it look real. Overall, the process is pretty much similar to above steps. We’ll need to scale the shadow and modify its transparency level in accordance with the ball’s movement.

Here is the final result of the jumping ball animation.

Conclusion

Making 2D animation is a piece of cake with proper software. Thanks to automated image transformation between keyframes, curve animation and multiple transition effects, creating an animated picture or a movie can be done in several minutes, even by a beginner.

GameDev.net Open License

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"Article" shall refer to any body of text written by Author which describes and documents the use and/or operation of Source or describes some process for   It specifically does not refer to any

"Author" means the individual or entity that offers the Work under the terms of this License.

"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.

"You" (or "Your") shall mean an individual or entity exercising permissions granted by this License.

"Source" shall include all software text source code and configuration files used to create executable software

"Object" shall mean any Source which has been converted into a machine executable software

"Work" consists of both the Article and Source

"Publisher" refers to GameDev.net LLC

2. Fair Dealing Rights.

3. Grant of Copyright License.

• You may not reproduce the Article on any other website outside of Gamedev.net without express written permission from the Author
• You may use, copy, link, modify and distribute under Your own terms, binary Object code versions based on the Work in your own software
• You may reproduce, prepare derivative Works of, publicly display, publicly perform, sublicense, and distribute the Source and such derivative Source in Source form only as part of a larger software distribution and provided that attribution to the original Author is granted and that a copy of this License is included.
• The origin of this Work must not be misrepresented; you must not claim that you wrote the original Source. If you use this Source in a product, an acknowledgment of the Author name would be appreciated but is not required.

4. Restrictions.

• Altered Source versions must be plainly marked as such, and must not be misrepresented as being the original software.
• This License must be visibly linked to from any online distribution of the Article by URI and using the descriptive text "Licensed under the GameDev.net Open License"
• Neither the name of the Author of this Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Work without express prior permission of the Author
• Except as expressly stated herein, nothing in this License grants any license to Author's trademarks, copyrights, patents, trade secrets or any other intellectual property. No license is granted to the trademarks of Author even if such marks are included in the Work. Nothing in this License shall be interpreted to prohibit Author from licensing under terms different from this License any Work that Author otherwise would have a right to license.

5. Grant of Patent License.

6. Limitation of Liability.

7. DISCLAIMER OF WARRANTY

8. Publisher.

9. Termination

Every game developer on this planet is entitled to the very best learning and resource information on their craft..  and this information needs to be free to use and easily accessible.

The community needs your help to build this resource library.

Note:  If you are ready to get started then read about how to publish articles on Gamedev.net.  Otherwise, keep on reading!

The Tools

• Understand core-programming concepts
• Understand basic input
• Understand basic game loop

• FlashDevelop 4.0
• Flash CS 5.5 for graphics

Introduction

Note:  Please note that the tutorial will not be covering menus. It is purely designed to focus on the game itself, and leaves it up to each individual user to add any menu system.  

The Result

Note:  The "Click to play" and black background were added after this tutorial, and are the only changes between the above game, and this tutorial.  All code and resources were created by the author, and is included as an attachment to this tutorial, all images are also attached the associated .rar file, incase over time those images have broken.

The Grid

The very first thing when building PAC-MAN is to think about how you will represent the game's world.  PAC-MAN is a very simple world.  The world consists of a series of tiles where most tiles contain a pellet.   Once all the pellets are eaten we reset the grid.

We will use a 1D array to represent our tiles:

package  {
	//Import some librarys from flash that we will need.
	import flash.display.Bitmap; //For Images
	import flash.display.Sprite; //A sprite is essentially a container object for drawable objects.
	public class Game { //We will call this class Game, it will be responsible for controlling the entire game.
		public static const TileWidth:Number = 32.0; //Each tile will be 32 pixels wide.
		public static const TileHeight:Number = 32.0; //Each tile will be 32 pixels high.
		public var m_Tiles:Array = []; //The array for containing all of our Tiles.
		public var m_Width:int  //How many tiles wide is the grid.
		public var m_Height:int; //How many tiles high is the grid.
		public var m_Sprite:Sprite = new Sprite(); //We have our own sprite for drawing into, this will also be helpful for translating the camera around the player later.

	}
};

package  {
	//Import some librarys to allow the tile to control it's own rendering.
	import flash.display.Bitmap;
	import flash.display.Sprite;
	public class Tile {
		//We require 4 boolean values, is the tile closed, does it have a pellet, is that pellet big. and when reseting the tile, we need to know if we should give it a pellet.
		//Insead of using 4 variables, we instead use 4 bits from an int variable, and use bit-wise operations to check the flags.
		
		//So we statically define each flag, and the bit that represents flag.
		public static const CLOSED:int = 1;       //Used to tell if the tile is passable or not.
		public static const HASPELLET:int = 2;    //Used to check if the tile currently has a pellet or not.
		public static const HASBIGPELLET:int = 4; //Used to check if the pellet is a normal pellet, or a pellet that allows us to eat the ghosts.
		public static const NOPELLET:int = 8;     //An additional flag, that allows the tile to be open, but allows us to not to give it a pellet when we don't have to.
		public var m_Flag:int;  //The flag used for representing the tile's current state.
		public var m_Sprite:Sprite = new Sprite(); //The sprite that well be used for rendering the tile.
		public var m_Index:int; //The index of the tile, in the game tile array.

		public function Tile(Flag:int, i:int){ //The constructor for the tile, we pass the starting flag, and the index position.
			m_Flag = Flag;
			m_Index = i;
		}

	}

}

public class Game{
	... //The ... represents the code segment from above.
	
	public function Game(S:Sprite){ //Defining the constructor for the game object, we also want to pass a sprite that we will use for drawing into.
		//To start off, we are going to generate a 10x10 grid.
		m_Width = 10;
		m_Height= 10;
		//If you are using another language, this would be where you would define the size of the array.
		for(var i:int = 0; i < m_Width*m_Height; i++) m_Tiles[i] = new Tile(0, i); //we define each initial tile as open
		//Let's close a few tiles, so we can demonstrate the rendering capabiltys of tiles which are closed off:
		//To calculate a tile based on an x, and y position, we simply use the following formula: Tile = x+y*m_Width;
		m_Tiles[11].m_Flag|=Tile.CLOSED; //Let's close the tile at 1,1 on the grid, which is Tile = 1+1*10 = 11
		m_Tiles[12].m_Flag|=Tile.CLOSED; //Let's also close the tile next to 1,1 at 2,1.  which is Tile = 2+1*10 = 12;
		m_Tiles[21].m_Flag|=Tile.CLOSED; //Let's close a couple tiles undeaneath the above two tiles, 1,2 and 2,2 which is Tile = 1+2*10 = 21
		m_Tiles[22].m_Flag|=Tile.CLOSED; //Tile = 2+2*10 = 22
		

		CalculateSprites(); //Now let's figure out how to draw the tiles.
		for(int i=0;i<m_Width*m_Height;i++) m_Sprite.addChild(m_Tiles[i].m_Sprite); //Add all the tiles to our sprite.
		S.addChild(m_Sprite); //then let's add our sprite to the parent sprite.
	}
};

public class Game{
	...
	//We need a couple helper functions for determing the position of the tile in screen coordinates.
	public function GetTileX(T:Tile):Number {
		return (T.m_Index % m_Width) * TileWidth; //we need to find the x position of the tile in the grid, so we take the index, and mod it against the width of the grid, to get the screen position, we multiply by each tile's size(defined above.)
	}

	public function GetTileY(T:Tile):Number {
		return (int) (T.m_Index / m_Width) * TileHeight; //we need to find the y position of the tile in the grid, so we take the index, and divide if against the width of the grid, why divide by width, because our formula for calculating an x/y to tile index is: x+y*m_Width, as such, we to get back to a y position, we need to divide by width, not height.
		//we also need to truncate the value to the floored integer value, otherwise we won't get a real number for y.  since we want the floored number, simply typecasting to int drops the decimals after division.
	}

	//A few things we pass to the function, the Tile that we want to find the neighbors for.
	//the x and y distance we want to translate around, for example -1,0 is left, 1,0 is right, 0,-1 is above, and 0,1 is below.
	//Finally, should we wrap the value and get the tile on the other side, or should we say that we are a border tile?
	public function GetTileNeighbor(T:Tile, xd:int, yd:int, wrap:Boolean):Tile {
		var TileX:int = T.m_Index % m_Width + xd; //Let's calculate the target tile's x position, we take our index and mod it against the total width of the world, finally we add the x distance we want to travel.
		var TileY:int = T.m_Index / m_Width + yd; //Let's calculate the target tile's y position, we take our index, and divide it gainst the total width of the world.  why the width, because our function for caluclating tiles is: x+y*m_Width, so we natually have to divide by width to get the y position, we also neet to truncate the value to the floored whole integer.  finally we add the y distance we want to travel.
		if (wrap) { //If we want to wrap to the other side of the grid, then we check this boolean.
			if (TileX < 0) TileX += m_Width; //if our target x position is less than 0, we add the width to it, and that well place us on the other side of the grid.
			else if (TileX >= m_Width) TileX -= m_Width; //if we are however are greather than, or equal to the width of the world, then we need to subtract to get to the other side of the grid.
			if (TileY < 0) TileY += m_Height; //We do the same as above for y, but instead we use the height instead of width.
			else if (TileY >= m_Height) TileY -= m_Height;
		}else{ //We don't want to wrap around the world, so if the target tile is outside the grid boundarys, we need to return a null tile.
			if (TileX < 0) return null;
			else if (TileX >= m_Width) return null;
			if (TileY < 0) return null;
			else if (TileY >= m_Height) return null;
		}
		return m_Tiles[TileX + TileY * m_Width]; //now that we've found a target tile, and it is valid, we can return it.
	}
	//This function can crash if xd, or yd is >= width/height, and wrap is set to true.  however we will never have to supply such large value's, so their's no reason to worry about such a thing.
};

public class Game{
	...
	//In flash, we need to embed resources as variables, and create a generic class that is the resource(in this instance we create 3 bitmaps).
	//If you are using another language, think of these as textures, and make sure to only load them once.
	//If you are using flashdevelop, make sure the objects are added to the library correctly, an explanations on how to link resources to the game is outside the scope of this article.
	[Embed(source="../lib/Bar_A.png")] //#1
	private var Bar_ASprite:Class;
	[Embed(source="../lib/Bar_B.png")] //#2
	private var Bar_BSprite:Class;
	[Embed(source="../lib/Bar_C.png")] //#3
	private var Bar_CSprite:Class;

	//to make the code look a little bit more fluent, we define a helper function for translating bitmaps when they are attached to the tiles.
	public function ApplyTranslation(B:Bitmap, Rotation:Number, x:Number, y:Number):Bitmap {
		B.rotation = Rotation; //Rotations are in degrees.
		B.x = x; //apply translations to the bitmap for rendering.
		B.y = y;
		return B; //Return this bitmap, using this function, makes writing one liner's in the calculateSprite easier.
	}

	//This is the heavy duty rendering function:
	public function CalculateSprites():void {
		for (var i:int = 0; i < m_Width * m_Height; i++) {//Loop through all the tiles.
			var T:Tile = m_Tiles[i]; //Create a local variable of the tile, this is purely to write a bit less.
			if ((T.m_Flag&Tile.CLOSED)!=0) { //We check if this tile is closed, if so, then we want to attach some borders to it.
				var LeftTile:Tile  = GetTileNeighbor(T, -1, 0, false); //Let's get the left tile.
				var RightTile:Tile = GetTileNeighbor(T,  1, 0, false); //Right tile
				var TopTile:Tile   = GetTileNeighbor(T,  0,-1, false); //Above tile
				var BtmTile:Tile   = GetTileNeighbor(T,  0, 1, false); //Below tile.
				
				//We need to know which side's to add bar's to.
				var BarLft:Boolean = (LeftTile  != null && (LeftTile.m_Flag  & Tile.CLOSED) == 0); //Check that the tile is not null, then check that it isn't closed.
				var BarRgt:Boolean = (RightTile != null && (RightTile.m_Flag & Tile.CLOSED) == 0); //" "
				var BarTop:Boolean = (TopTile   != null && (TopTile.m_Flag   & Tile.CLOSED) == 0); //" "
				var BarBtm:Boolean = (BtmTile   != null && (BtmTile.m_Flag   & Tile.CLOSED) == 0); //" "

				//Now we need to select an appropiate bitmap, since we are rendering clockwise.
				var TopBar:Bitmap = BarTop?(BarLft?new Bar_CSprite():(BarRgt?new Bar_BSprite():new Bar_ASprite())):null;
				//If you are not familar with the ? symbol, here's what the above logic comes out to:
				//var TopBar:Bitmap;
				//If(BarTop==true){
				//	if(BarLft==true)      TopBar = new Bar_CSprite();
				//	else if(BarRgt==true) TopBar = new Bar_BSprite();
				// else                   TopBar = new Bar_ASprite();
				//}else                   TopBar = null;
				//So, basically what this boils down to is: if we need to draw a bar on the top, then which one to choose?:
				//if we are also drawing a bar on the left, then we know that the left bar is going to choose to draw Bar #2
				//however, if we are instead drawing a bar on the right, then we know that the bar on the right is going to pick #3
				//and finally, if both left and right are not going to be drawn into, then we know both our neighbors are closed, so we select #1


				var BtmBar:Bitmap = BarBtm?(BarRgt?new Bar_CSprite():(BarLft?new Bar_BSprite():new Bar_ASprite())):null; //Repeat the above logic with the rest of the bitmaps.
				var LftBar:Bitmap = BarLft?(BarBtm?new Bar_CSprite():(BarTop?new Bar_BSprite():new Bar_ASprite())):null;
				var RgtBar:Bitmap = BarRgt?(BarTop?new Bar_CSprite():(BarBtm?new Bar_BSprite():new Bar_ASprite())):null;
				if (TopBar != null) T.m_Sprite.addChild(ApplyTranslation(TopBar,  0.0,   0.0,  0.0)); //If we have a bar to draw, we need to translate it to be placed correctly on the tile, we then add the bitmap to the tile's sprite container.
				if (BtmBar != null) T.m_Sprite.addChild(ApplyTranslation(BtmBar, 180.0, 32.0, 32.0)); //See below for an explanation for why we choose our x and y treanslations.
				if (LftBar != null) T.m_Sprite.addChild(ApplyTranslation(LftBar, 270.0,  0.0, 32.0));
				if (RgtBar != null) T.m_Sprite.addChild(ApplyTranslation(RgtBar,  90.0, 32.0,  0.0));
			}
			T.m_Sprite.x = GetTileX(T); //Now we need to position the tile at the correct position for the screen.
			T.m_Sprite.y = GetTileY(T); //Do the same for the y.
		}
	}
};

package {
	import flash.display.Sprite;

	public class Main extends Sprite {
		public var m_Game:Game = null; //Because we are going to be using callbacks later, we make this a public variable.

		//If you are using another language, this is our entry point/
		public function Main():void {
			m_Game = new Game(this); //Now we create an instance of the game.
		}
	}
};

public class Game{
	...
	
	public function Game(S:Sprite){
        ...
        //for(var i:int = 0; i < m_Width*m_Height; i++) m_Tiles[i] = new Tile(0, i); //change this line into:
        for(var i:int = 0; i < m_Width*m_Height; i++) m_Tiles[i] = new Tile(((i % m_Width) == 0 || (i % m_Width) == (m_Width - 1) || ((int)(i / m_Width)) == 0 || ((int)(i / m_Width)) == (m_Height - 1))?Tile.CLOSED:0, i);
		//The above code sets the entire border around the map to be closed.
        ...
	}
};

public class Game{
	...
	public var m_TotalPellets:int; //We need to track the total number of pellets.
	public var m_EatenPellets:int; //We need to track the number of eaten pellets.
	...
	//We need to embed two new bitmaps, the pellet, and the BigPellet.  the BigPellet is our ghost eating pellet.
	[Embed(source = "../lib/Pellet.png")]
	private var PelletSprite:Class;
	[Embed(source = "../lib/BigPellet.png")]
	private var BigPelletSprite:Class;

	//Add a function for building the pellet's for each tile.
	public function ResetPellets():void {
		//Reset both values to 0.
		m_TotalPellets = 0;
		m_EatenPellets = 0;
		for (var i:int = 0; i < m_Width * m_Height; i++) { //Loop through all the tiles.
			var T:Tile = m_Tiles[i]; //Make a variable to represent the tile.
			if ((T.m_Flag & (Tile.CLOSED|Tile.NOPELLET)) == 0) { //We check that the tile can have a pellet(that their is no NOPELLET flag set), and that it isn't a closed tile.
				//Now we add a pellet image to the tile, we also check if we need to add a big pellet, or a regular pellet.
				if((T.m_Flag&Tile.HASPELLET)==0){
					//Because this function could be called when all the tile's haven't been eaten, we need to check if it's ok to add the sprite onto the tile.
					T.m_Sprite.addChild((T.m_Flag&Tile.HASBIGPELLET)==0?new PelletSprite():new BigPelletSprite());
				}
				m_TotalPellets++; //Incrment the total number of pellets.
				T.m_Flag |= Tile.HASPELLET; //Make the tile so that we will know it has a pellet.
			}
		}
		return;
	}
	
	public function Game(S:Sprite){
		...
		...CalculateSprites(); //Include after this line:
		ResetPellets();
		...
	}
};

The Player

So, now that we have our grid, we want to add a player.
The first thing to think about with a player, is that the player should simply be an extension of the ghosts, rather than making a unique class for each.

Let's call this new class Unit

package{
	import flash.display.MovieClip;
	import flash.display.Sprite;

	public class Unit{
		//Define some constants for directions.
		public static const DIR_LEFT:int = 0;
		public static const DIR_UP:int = 1;
		public static const DIR_RIGHT:int = 2;
		public static const DIR_DOWN:int = 3;
		public var m_Tile:Tile; //Get the current tile we are on.
		public var m_Sprite:MovieClip; //The animation movie clipe for the sprite(note that if you are using another language, you will have to provide your own animation system.)
		public var m_Direction:int = DIR_LEFT; //The direction we are facing.

		//Constructor for a unit, we provide the tile it's on, the Game, and the movieclip representing the object.
		public function Unit(T:Tile, Gm:Game, MC:MovieClip){
			m_Tile = T;
			m_Sprite = MC;
			m_Sprite.x = Gm.GetTileX(m_Tile) + Game.TileWidth * 0.5; //We add an offset, because the movieclip is centered at it's orgin, instead of the top left, we need to add half the MC's width to the sprite's position(note that the MC size should be equal to the TileWidth defined in Game.)
			m_Sprite.y = Gm.GetTileY(m_Tile) + Game.TileHeight * 0.5; //Again, set the sprite's position, relative to the parent sprite.
		}


	}
};

public class Game{
	...
	public var m_Units:Array = []; //The array for containing all of our units.
	...
	public function Game(S:Sprite){
		...m_Tiles[22].m_Flag|=Tile.CLOSED;
		m_Units[0] = new Player(m_Tiles[55], this, new Player());
		//we select a tile at 5,5 to place our player, and we select the Player MC.
		//Note that Player is a class inside the Player.swc file, when it's included in the flash library, the class is made available for creating
		//Movieclips, this part can be a bit confusing if translating into a language that doesn't have a library system the way flash works.
		//Essentially you would pass a player animation sprite from w/e you are using for your animation system.
		...
		...for (i = 0; i < m_Width * m_Height; i++) m_Sprite.addChild(m_Tiles[i].m_Sprite); //Add after this line:
		for(i = 0; i < m_Units.length; i++) m_Sprite.addChild(m_Units[i].m_Sprite); //Add all the units to our sprite.
		...
	}

};

public class Game{
	...

	//The Update function, where our entire game logic is handled:
	public function Update():Boolean { //We will return a boolean, later we can use this to determine if the game is over.
		var i:int;
		for (i = 0; i < m_Units.length; i++) m_Units[i].Update(this); //We'll get to this function later, but each unit well control updating itself.
		return false; //Game is not over yet!
	}
};

package{
	...
	import flash.events.Event;
	public class Main{
		...
		//Update callback function in flash.
		public function UpdateFunc(E:Event):void{
			m_Game.Update()
			return;
		}
		...
		public function Main():void{
			...m_Game = new Game(this); //Add after this line:
			stage.addEventListener(Event.ENTER_FRAME, UpdateFunc); //Set callback for updating, this function well get called at a rate equal to the number of frames per second the swf is set to play at.
			//Note that if this is being translated to another language, you can alternativly start your main game loop here, just be sure to call UpdateFunc inside your time-step code.
		}
	};
}

public class Unit{
	...
	public static const MaxTicks:int = 10; //The number of frames(or times that update will be called) that it will take to move to another tile, I short hand this to calling it tick, instead of frames.  since we assume the game well run at 60 frames(or ticks) per second.  Then that means we move from one tile to another every 1/6th a second.
	public static const MaxFrames:int = 30; //The number of frames that a particular segment of animation length.
	public var m_Tick:int = 0; //The current tick, once we are >= to MaxTicks we will have moved to another tile.

	//Unit Update function!
	public function Update(Gm:Game):void {
		//Figure out which way we are heading:
		var TarX:int = (m_Direction == DIR_LEFT? -1:(m_Direction == DIR_RIGHT?1:0));
		//This code boils out to being:
		//public var TarX = 0;
		//if(m_Direction==DIR_LEFT) TarX = -1;
		//else if(m_Direction==DIR_RIGHT) TarX = 1;
		var TarY:int = (m_Direction == DIR_UP  ? -1:(m_Direction == DIR_DOWN?1:0)); 
		var TarTile:Tile = Gm.GetTileNeighbor(m_Tile, TarX, TarY, false);//We will deal with wrapping later, for now we get our target tile!
		if (TarTile != null && (TarTile.m_Flag & Tile.CLOSED) == 0) { //Check that the target is a valid file.
			m_Tick++; //Increment our ticks.
			if (m_Tick >= MaxTicks) { //We are on, or exceeding the target ticks.
				m_Tick = 0; //Reset ticks
				m_Tile = TarTile; //Set us on the target tick.
			}
		}else m_Tick = 0; //If the target is null, or is closed, then we reset the ticks.
		var Percent:Number = m_Tick / MaxTicks; //We get a percentage we have moved from the our tile, toward the target.
		var CurrentTileX:Number = Gm.GetTileX(m_Tile); //Get our tile x.
		var CurrentTileY:Number = Gm.GetTileY(m_Tile); //Get our tile y.
		var TargetTileX:Number  = Gm.GetTileX(TarTile); //Get target tile x.
		var TargetTileY:Number  = Gm.GetTileY(TarTile); //Get target tile y.
		m_Sprite.x = CurrentTileX + (TargetTileX - CurrentTileX) * Percent + Game.TileWidth * 0.5; //Move our x position as a percentage of distance between the current tile, and the target tile.
		m_Sprite.y = CurrentTileY + (TargetTileY - CurrentTileY) * Percent + Game.TileHeight * 0.5; //Move our y position as a percentage of distance between the current tile, and the target tile.
		var FirstFrame:int = m_Direction * 30 + 1; //Calculate the first frame.
		var LastFrame:int = (m_Direction + 1) * 30; //Calcuate the last frame in the animation segment. 
		//Note that the animation in the Player swf is made in diffrent segments of 30 frames, each segment lines up with the Direction variable. (i.e frames 1-30 are for when the player is facing left, 31-60 up, 61-90 right, 91-120 down)
		if (m_Sprite.currentFrame < FirstFrame || m_Sprite.currentFrame >= LastFrame) { //If our animation frame is outside the segment, set it back to the target segment:
			m_Sprite.gotoAndPlay(FirstFrame); //Let's goto and play our first frame.
		}
		return;
	}
};

public class Main{
	...
	//Setup several key flags, so we can change direction:
	public static const LeftFlag:int  = 1;
	public static const UpFlag:int    = 2;
	public static const RightFlag:int = 4;
	public static const DownFlag:int  = 8;
	public var m_KeyFlag:int = 0; //Key flag, for representing our target direction.

	public function UpdateFunc(E:Event):void{
		...m_Game.Update(); //Add after this line:
		//Set our player's direction, we assume that he is Unit 0.
		if      ((m_KeyFlag & LeftFlag)  != 0) m_Game.m_Units[0].SetDirection(Unit.DIR_LEFT);
		else if ((m_KeyFlag & UpFlag)    != 0) m_Game.m_Units[0].SetDirection(Unit.DIR_UP);
		else if ((m_KeyFlag & RightFlag) != 0) m_Game.m_Units[0].SetDirection(Unit.DIR_RIGHT);
		else if ((m_KeyFlag & DownFlag)  != 0) m_Game.m_Units[0].SetDirection(Unit.DIR_DOWN);

	}

	//SetKey callback:
	public function SetKey(Key:String, Down:Boolean):void {
		//Evaluate if the key is a valid one, and then modify the appropiate flag.
		if (Key == 'a')      m_KeyFlag = Down?(m_KeyFlag | LeftFlag)  : (m_KeyFlag & ~LeftFlag);
		//The above boils down to:
		// if(Down) m_KeyFlag |= LeftFlag;
		// else m_KeyFlag &= ~LeftFlag;
		
		else if (Key == 'w') m_KeyFlag = Down?(m_KeyFlag | UpFlag)    : (m_KeyFlag & ~UpFlag);
		else if (Key == 'd') m_KeyFlag = Down?(m_KeyFlag | RightFlag) : (m_KeyFlag & ~RightFlag);
		else if (Key == 's') m_KeyFlag = Down?(m_KeyFlag | DownFlag)  : (m_KeyFlag & ~DownFlag);
	}
	
	//KeyUp callback:
	public function KeyUp(KeyEvent:KeyboardEvent) {
		//We need to set the key appropiate key flag, for when changing directions.
		SetKey(String.fromCharCode(KeyEvent.charCode), false);
		return;
	}
	//KeyDown callback:
	public function KeyDown(KeyEvent:KeyboardEvent) {
		SetKey(String.fromCharCode(KeyEvent.charCode), true);
		return;
	}
	...

	public function Main():void {
		...stage.addEventListener(Event.ENTER_FRAME, UpdateFunc); //add afterL
		//Add Keyboard callbacks
		stage.addEventListener(KeyboardEvent.KEY_UP, KeyUp);
		stage.addEventListener(KeyboardEvent.KEY_DOWN, KeyDown); 
	}
}

public class Unit{
	...
	public var m_TarDirection:int = DIR_LEFT; //The target direction for changing.
		
	public function Update(Gm:Game):void{
		...m_Tile = TarTile //Add after this line:
		ChangeDirection(Gm); //Change our direction if we can/have to.
		...modify the }else m_Tick = 0; To:
		}else{
			m_Tick = 0;
			ChangeDirection(Gm); //Change our direction.
		}
	}

	//Change the direction if we can.
	public function ChangeDirection(Gm:Game):void {
		if (m_TarDirection == m_Direction) return; //If we are already facing our target direction, then return.
		var TarX:int = (m_TarDirection == DIR_LEFT? -1:(m_TarDirection == DIR_RIGHT?1:0)); //Get the target x distance.
		var TarY:int = (m_TarDirection == DIR_UP? -1:(m_TarDirection == DIR_DOWN?1:0)); //Get the target y distance.
		var TarTile:Tile = Gm.GetTileNeighbor(m_Tile, TarX, TarY, false); //Get the target tile, we'll handle wrapping later.
		if (TarTile != null && (TarTile.m_Flag & Tile.CLOSED) == 0) m_Direction = m_TarDirection; //Valid direction, so let's head that way.
		m_TarDirection = m_Direction; //Reset the target direction.
		return;
	}
	
	//Set the target direction.
	public function SetDirection(Dir:int):void {
		m_TarDirection = Dir;
		return;
	}
};

public class Unit{
	...
	public function Update(Gm:Game):void{
		...m_Tile = TarTile; //Add after this line:
		Gm.EatPellet(m_Tile); //Let's eat the pellet on our current tile.
	}
}

public class Game{
	...
	public function EatPellet(T:Tile):void{
			if ((T.m_Flag & Tile.HASPELLET) != 0) { //Check that we have a pellet.
				T.m_Sprite.removeChildAt(T.m_Sprite.numChildren - 1); //Since the pellet is the last child, then we need to remove it from being drawn.
				T.m_Flag ^= Tile.HASPELLET; //Remove the pellet flag, so we can't eat this tile's pellet.
				
				m_EatenPellets++; //Increment our eaten pellets.
				
			}
			return;
	}
};

public class Game{
	...
	public static const PlayerSpawnTile:Number = 55; //Constant of where to player the player on spawn.
	public var m_Finished:Boolean; //Used for re-setting the player.

	public function Update():Boolean {
		...for (i = 0; i < m_Units.length; i++) m_Units[i].Update(this); //add after this line:
		if (m_Finished) ResetPlayer();
		return false;
	}

	public function EatPellet(T:Tile):void {
		...m_EatenPellets++; //add after this line
		if (m_EatenPellets == m_TotalPellets) {
			m_Finished = true;
			ResetPellets();
		}
		return;
	}

	//Reset Player function:
	public function ResetPlayer():void {
		for (var i:int = 0; i < m_Units.length; i++) { //Reset units.
			m_Units[i].m_Tile = m_Tiles[PlayerSpawnTile]; //Set tile to player position.
			m_Units[i].m_Tick = 0; //Reset ticks
			m_Units[i].m_Direction = m_Units[i].m_TarDirection = Unit.DIR_LEFT; //Reset direction
		}
		m_Finished = false;  //Reset finished flag.
		return;
	}
	
	public function Game(Gm:Game){
		...ResetPellets(); //Add after this line
		ResetPlayer(); //Setup the player.
	}
};

public class Unit{

	//Ranged rectangle tile flag setting, helps with creating the grid alot easier.
	public function SetTileFlagRange(x:int, y:int, w:int, h:int, flag:int):void {
		for (var ix:int = x; ix < x + w; ix++) {
			for (var iy:int = y; iy < y + h; iy++) m_Tiles[ix + iy * m_Width].m_Flag = flag;
		}
		return;
	}

	public function Game(S:Sprite){
		...
		m_Width = 28; //The pac-man board is 28x31 tiles.
		m_Height= 31;
		...Remove the following lines:
		m_Tiles[11].m_Flag|=Tile.CLOSED; //Let's close the tile at 1,1 on the grid, which is Tile = 1+1*10 = 11
		m_Tiles[12].m_Flag|=Tile.CLOSED; //Let's also close the tile next to 1,1 at 2,1.  which is Tile = 2+1*10 = 12;
		m_Tiles[21].m_Flag|=Tile.CLOSED; //Let's close a couple tiles undeaneath the above two tiles, 1,2 and 2,2 which is Tile = 1+2*10 = 21
		m_Tiles[22].m_Flag|=Tile.CLOSED; //Tile = 2*2*10 = 22
		...And add in it's place:
		//Setup the entire grid to look like a pac-man board:
		SetTileFlagRange( 2,  2,  4, 3, Tile.CLOSED);
		SetTileFlagRange( 7,  2,  5, 3, Tile.CLOSED);
		SetTileFlagRange(13,  1,  2, 4, Tile.CLOSED);
		SetTileFlagRange(16,  2,  5, 3, Tile.CLOSED);
		SetTileFlagRange(22,  2,  4, 3, Tile.CLOSED);
		SetTileFlagRange( 2,  6,  4, 2, Tile.CLOSED);
		SetTileFlagRange( 7,  6,  2, 8, Tile.CLOSED);
		SetTileFlagRange( 0,  9,  6, 5, Tile.CLOSED);
		SetTileFlagRange(10,  6,  8, 2, Tile.CLOSED);
		SetTileFlagRange(19,  6,  2, 8, Tile.CLOSED);
		SetTileFlagRange(22,  6,  4, 2, Tile.CLOSED);
		SetTileFlagRange(22,  9 , 6, 5, Tile.CLOSED);
		SetTileFlagRange( 9,  9,  3, 2, Tile.CLOSED);
		SetTileFlagRange(13,  8,  2, 3, Tile.CLOSED);
		SetTileFlagRange(16,  9,  3, 2, Tile.CLOSED);
		SetTileFlagRange(10, 12,  8, 5, Tile.CLOSED);
		SetTileFlagRange(11, 13,  6, 3, Tile.NOPELLET);
		SetTileFlagRange( 0, 14,  6, 1, Tile.NOPELLET);
		SetTileFlagRange(22, 14,  6, 1, Tile.NOPELLET);
		SetTileFlagRange( 0, 15,  6, 5, Tile.CLOSED);
		SetTileFlagRange(22, 15,  6, 5, Tile.CLOSED);
		SetTileFlagRange( 7, 15,  2, 5, Tile.CLOSED);
		SetTileFlagRange(19, 15,  2, 5, Tile.CLOSED);
		SetTileFlagRange(10, 18,  8, 2, Tile.CLOSED);
		SetTileFlagRange( 2, 21,  4, 2, Tile.CLOSED);
		SetTileFlagRange( 7, 21,  5, 2, Tile.CLOSED);
		SetTileFlagRange(13, 19,  2, 4, Tile.CLOSED);
		SetTileFlagRange(16, 21,  5, 2, Tile.CLOSED);
		SetTileFlagRange(22, 21,  4, 2, Tile.CLOSED);
		SetTileFlagRange( 4, 23,  2, 3, Tile.CLOSED);
		SetTileFlagRange(22, 23,  2, 3, Tile.CLOSED);
		SetTileFlagRange( 0, 24,  3, 2, Tile.CLOSED);
		SetTileFlagRange(25, 24,  3, 2, Tile.CLOSED);
		SetTileFlagRange( 2, 27, 10, 2, Tile.CLOSED);
		SetTileFlagRange(16, 27, 10, 2, Tile.CLOSED);
		SetTileFlagRange( 7, 24,  2, 3, Tile.CLOSED);
		SetTileFlagRange(10, 24,  8, 2, Tile.CLOSED);
		SetTileFlagRange(19, 24,  2, 3, Tile.CLOSED);
		SetTileFlagRange(13, 26,  2, 3, Tile.CLOSED);
		SetTileFlagRange( 1,  3,  1, 1, Tile.HASBIGPELLET);
		SetTileFlagRange(26,  3,  1, 1, Tile.HASBIGPELLET);
		SetTileFlagRange( 1, 23,  1, 1, Tile.HASBIGPELLET);
		SetTileFlagRange(26, 23,  1, 1, Tile.HASBIGPELLET);
		...

	}
};

public class Game{
	
	//We need to pass the stage to the function for the camera.
	public function Update(s:Stage):Boolean { //We will return a boolean, later we can use this to determine if the game is over.
		...for (i = 0; i < m_Units.length; i++) m_Units[i].Update(this);//Add After:

		//Camera controls:
		m_Sprite.x = -m_Units[0].m_Sprite.x + s.stageWidth * 0.5; //because the camera is actually the sprite itself, we are working along the negative x/y axis.
		m_Sprite.y = -m_Units[0].m_Sprite.y + s.stageHeight * 0.5; //set the sprite to our player's position plus half the stages width.
		if (m_Sprite.x > 0.0) m_Sprite.x = 0.0; //Check if the sprite is to far right,
		else if (m_Sprite.x - s.stageWidth < -m_Width * TileWidth) m_Sprite.x = -m_Width * TileWidth + s.stageWidth; //Check that it isn't too far left.
		if (m_Sprite.y > 0.0) m_Sprite.y = 0.0; //Repeat with 'y's.
		else if (m_Sprite.y - s.stageHeight < -m_Height * TileHeight) m_Sprite.y = -m_Height * TileHeight + s.stageHeight;
		...
	}
};

public class Game{
	...
	public function UpdateFunc(E:Event):void{
		m_Game.Update(stage);
	}
};

public class Game{
	...
	public static const PlayerSpawnTile:Number = 658; //Constant of where to player the player on spawn.
	
};

public class Unit{
	...	
	public function Update(Gm:Game):void{
		...var TarTile:Tile = Gm.GetTileNeighbor(m_Tile, TarX, TarY, false);	//Modify this line into:
		var TarTile = Gm.GetTileNeighbor(m_Tile, TarX, TarY, true);		
		...var TargetTileY:Number  = Gm.GetTileY(TarTile); //Add after this line:		
		//If the target position is greater than half the width of the game grid, then we know that we need to offset the target because we are wrapping around the grid.		
		if      (TargetTileX < CurrentTileX - Gm.m_Width  * Game.TileWidth  * 0.5) TargetTileX += Gm.m_Width  * Game.TileWidth; 		
		else if (TargetTileX > CurrentTileX + Gm.m_Width  * Game.TileWidth  * 0.5) TargetTileX -= Gm.m_Width  * Game.TileWidth; 		
		if      (TargetTileY < CurrentTileY - Gm.m_Height * Game.TileHeight * 0.5) TargetTileY += Gm.m_Height * Game.TileHeight;		
		else if (TargetTileY > CurrentTileY + Gm.m_Height * Game.TileHeight * 0.5) TargetTileY -= Gm.m_Height * Game.TileHeight;	
	}		
	public function ChangeDirection(Gm:Game):void{		
		...var TarTile:Tile = Gm.GetTileNeighbor(m_Tile, TarX, TarY, false); //Modify into:		
		var TarTile:Tile = Gm.GetTileNeighbor(m_Tile, TarX, TarY, true);	}	
		...
	}
}

The Computer

Let's start by adding our first ghost:

public class Game{
	...
	public static const GhostSpawnTile:Number = 322;  //Constraint of where to place the ghost on spawn.
	public static const GhostPreSpawnTile:Number = 374; //Constrint of where to place the ghosts before they spawn.
	...
	public function ResetPlayer():void {
		...m_Units[i].m_Tile = m_Tiles[PlayerSpawnTile]; //Change line to:
		m_units[i].m_Tile = m_Tiles[(i==0)?PlayerSpawnTile:GhostPreSpawnTile];
		...
	}
	
	public function Game(S:Sprite):void{
		...m_Units[0] = new Unit(m_Tiles[PlayerSpawnTile], this, new Player()); //Add Line after:
		m_Units[1] = new Unit(m_Tiles[GhostPreSpawnTile], this, new Ghost_Orange()); //Add a ghost.
	}

public class Unit{

	public function Update(Gm:Game, AI:Boolean):void{ //Adding an ai flag to update the unit, and to allow it to make deceisions:
		...m_Tile = TarTile; //Add after this line
		if(AI){ //Check the ai flag.
			m_TarDirection = (int) (Math.random() * 4); //Randomly select a new direction.
			//We don't want to turn around each time we step on another tile, so:
			if ((m_TarDirection == DIR_LEFT && m_Direction == DIR_RIGHT) || (m_TarDirection == DIR_UP && m_Direction == DIR_DOWN) || (m_TarDirection == DIR_RIGHT && m_Direction == DIR_LEFT) || (m_TarDirection == DIR_DOWN && m_Direction == DIR_UP)) m_TarDirection = m_Direction;
		}else Gm.EatPellet(m_Tile); //only eat pellets if we are not an computer player.
		...m_Tick=0 //Add after line:
		//since this logic occurs when we are walking into a wall, it doesn't matter if we want to turn around, or not.
		if (AI) m_TarDirection = (int) (Math.random() * 4); //Randomly selects a new direction.
	}
};

public class Game{

	public function Update(s:Stage):Boolean{
		...for (i = 0; i < m_Units.length; i++) m_Units[i].Update(this); //Modify line to:
		for (i = 0; i < m_Units.length; i++) m_Units[i].Update(this, i>0); //Since the first object is the player, when i is greater than 0, it's an ghost.
	}
};

public class Game{
	public static const GhostSpawnTicks:int = 60 * 5; //60 ticks per second, so every 5 seconds a ghost will spawn if possible.
	...
	public var m_NextGhostTick:int; //When to spawn the ghost
	public var m_Tick:int; //Number of ticks that have gone by.
	
	public function Update(s:Stage):Boolean{
		...else if (m_Sprite.y - s.stageHeight < -m_Height * TileHeight) m_Sprite.y = -m_Height * TileHeight + s.stageHeight; //Add after this line:
		if (m_Tick >= m_NextGhostTick && m_NextGhostTick < m_Units.length * GhostSpawnTicks) { //Check if the number of ticks is greater then the spawn ticks, and that the number of ticks is less than the number of units times the ghsot spawn constant.
			m_Units[(int)(m_NextGhostTick / GhostSpawnTicks)].m_Tile = m_Tiles[GhostSpawnTile]; //Set the tile for the ghost to spawn on.
			m_NextGhostTick += GhostSpawnTicks; //Increment the ghost ticks.
		}
		m_Tick++; //Increment ticks.
		...
	}

	public function ResetPlayer():void {
		...m_Finished = false;  //add after this line:
		m_Tick = 0; //Reset ticks
		m_NextGhostTick = GhostSpawnTicks; //Reset ghost ticks.
		...
	}

public class Game{
	...
	public static const UnitDiameter:Number = 32.0;
	...

	public function Update(s:Stage):Boolean{
		...for (i = 0; i < m_Units.length; i++) m_Units[i].Update(this, i>0); //add after this line:
		//since we are only checking if the ghosts touch the player, we can start at 1:
		for (i = 1; i < m_Units.length; i++) {
			var DistanceX:Number = (m_Units[i].m_Sprite.x - m_Units[0].m_Sprite.x); //Get the x distance between the player, and the ghost.
			var DistanceY:Number = (m_Units[i].m_Sprite.y - m_Units[0].m_Sprite.y); //Get the y distance between the player, and the ghost.
			if (DistanceX * DistanceX + DistanceY * DistanceY <= UnitDiameter * UnitDiameter) { //Check that the distance squared between the player and the ghost, is less than the squared distance of the radius of the ghost, and the player then we are colliding.  Since both ghost and player have the same radius, we can use the diameter squared.
				m_Units[0].m_State |= Unit.UNIT_DEAD; //Mark the player as dead.
			}
		}
	}
	
	public function ResetPlayer():void{
		...m_Units[i].m_Direction = m_Units[i].m_TarDirection = Unit.DIR_LEFT; //add after:
		m_Units[i].m_State = 0; //Reset state.
	}
};

public class Unit{
	...
	public static const UNIT_DEAD:int = 1; //Constant for the state where the player is dead.
	...
	public var m_State:int = 0; //The state of the unit.
	...
	public function Update(Gm:Game, AI:Boolean):void {
		...m_Tick++; //Modify into:
		if((m_State&UNIT_DEAD)==) m_Tick++; //So long as the unit is not dead, we can keep moving.
		...ChangeDirection(Gm); //Modify both of these lines into:
		//check to ensure the unit isn't dead.
		if((m_State&UNIT_DEAD)==0) ChangeDirection(Gm); //Change our direction if we can to.
		...var LastFrame:int = (m_Direction + 1) * 30; //Add after this line:
		if ((m_State & UNIT_DEAD) != 0) { //If we are dead, set the first and last frame.
			FirstFrame = 121; //We have a segment of animation between frames 121 and 150.
			LastFrame = 150;
		}
		...if (m_Sprite.currentFrame < FirstFrame || m_Sprite.currentFrame >= LastFrame) //Modify this line into:
		if(m_Sprite.currentFrame < FirstFrame || m_Sprite.currentFrame >= LastFrame){
			if (m_Sprite.currentFrame >= LastFrame && (m_State & UNIT_DEAD) != 0) Gm.m_Finished = true; //If the unit is dead, and we've finished the animation, mark the game as finished.
			m_Sprite.gotoAndPlay(FirstFrame); //Let's goto and play our first frame.
		}
		...
	}
};

public class Game{
	public static const GhostKillTicks:int = 60 * 5; //60 ticks per second, so ghosts are killable for up to 5 seconds.
	...
	public var m_KillTick:int; //Number of ticks until we can reset the ghosts.

	public function Update(s:stage):Boolean{
		...m_Units[0].m_State |= Unit.UNIT_DEAD; //Modify the line into:
		if ((m_Units[i].m_State & Unit.GHOST_BLINK) != 0) m_Units[i].m_State ^= (Unit.GHOST_BLINK | Unit.GHOST_DEAD);
		else if ((m_Units[i].m_State & Unit.GHOST_DEAD) == 0) m_Units[0], m_State |= Unit.UNIT_DEAD;
		...
		...m_Tick++; //Add after this line:
		if (m_KillTick > 0) { //If the ghosts are blinking...
			m_KillTick--;  //Subtract kill ticks...
			if (m_KillTick == 0) { //If kill ticks is equal to 0
				for (i = 1; i < m_Units.length; i++) m_Units[i].m_State &= ~Unit.GHOST_BLINK; //Remove the blink flag from the ghosts.
			}
		}
	}

	public function EatPellet(T:Tile):void {
		...T.m_Flag ^= Tile.HASPELLET; //Add after this line
		if ((T.m_Flag & Tile.HASBIGPELLET) != 0) { //If we've eaten a big pellet, time to turn the ghosts:
			for (var i:int = 1; i < m_Units.length; i++) m_Units[i].m_State |= Unit.GHOST_BLINK;
			m_KillTick = GhostKillTicks;
		}
		...
	}
}

public class Unit{
	...
	public static const GHOST_DEAD:int = 2; //Constraint for the state, where the ghost is dead.
	public static const GHOST_BLINK:int = 4; //Constraint for the state, where the ghost is blinking.
	...

	public function Update(Gm:Game, AI:Boolean):void{
		
		...m_Tile = TarTile; //Add after this line:
		if ((m_State & GHOST_DEAD) != 0 && m_Tile == Gm.m_Tiles[Game.GhostSpawnTile]) m_State ^= GHOST_DEAD;

		...if(AI){ //Modify both lines that start here:
		if (AI) {
			//if we are dead, we want to get back to our spawn tile as quickly as possible:
			if ((m_State & GHOST_DEAD) != 0) m_TarDirection = CalculateBestDirection(Game.GhostSpawnTile, m_Tile, Gm, m_Direction);
			else m_TarDirection = (int) (Math.random() * 4); //Randomly select a new direction if we are

		...if ((m_State & UNIT_DEAD) != 0) { //Modify into:
		if ((m_State & GHOST_BLINK) != 0) { //if the ghost is blinking, override frames:
			FirstFrame += 120; //The ghosts have a second set of blinking animation, exactly 120 frames from their normal counterparts
			LastFrame  += 120;
		}else if ((m_State & GHOST_DEAD) != 0) { //if the ghost is dead, then we need to reset it.
			FirstFrame = 241; //The death animation segment.
			LastFrame = 270;
		}else if ((m_State & UNIT_DEAD) != 0) { //If we are dead, set the first and last frame.
	}

	//This function is for determing the heuristic(or value) of a tile toward it's target, we use the manhattan distance(add the x and y distance), to give a value to a tile relative to a target.
	public function CalculateHeuristic(TargetX:int, TargetY:int, Gm:Game, T:Tile):int {
		
		var CurrentX:int = T.m_Index % Gm.m_Width;       //Get the current x/y
		var CurrentY:int = (int)(T.m_Index / Gm.m_Width);
		return Math.abs(TargetX - CurrentX) + Math.abs(TargetY - CurrentY); //Return the combined distance from the current tile, and target.
	}
	
	//We want to choose the best direction to getting to a target tile.
	//But we don't want to do any real pathfinding, instead, we come to a comprimise of evalutating each available direction we can choose, and see which one get's us closer to our target.
	//We also try to make sure we don't choose the opposite direction we are heading now.
	public function CalculateBestDirection(TargetTile:int, CurrentTile:Tile, Gm:Game, Direction:int):int {
		var TargetX:int = TargetTile % Gm.m_Width;
		var TargetY:int = (int)(TargetTile / Gm.m_Width); //Caluclate the target's x and y.
		
		//Let's get all our neightbor tiles.
		var LeftTile:Tile  = Gm.GetTileNeighbor(CurrentTile,-1, 0, true);
		var RightTile:Tile = Gm.GetTileNeighbor(CurrentTile, 1, 0, true);
		var TopTile:Tile   = Gm.GetTileNeighbor(CurrentTile, 0,-1, true);
		var BtmTile:Tile   = Gm.GetTileNeighbor(CurrentTile, 0, 1, true);
		//Check if the tile is valid, then calculate the heuristic toard our destination, if it's invalid, then we set a null value(in this case it's int.MAX_VALUE)
		var LeftH:int   = (LeftTile  != null && (LeftTile.m_Flag  & Tile.CLOSED) == 0) ? CalculateHeuristic(TargetX, TargetY, Gm, LeftTile) :int.MAX_VALUE;
		var RightH:int  = (RightTile != null && (RightTile.m_Flag & Tile.CLOSED) == 0) ? CalculateHeuristic(TargetX, TargetY, Gm, RightTile):int.MAX_VALUE;
		var TopH:int    = (TopTile   != null && (TopTile.m_Flag   & Tile.CLOSED) == 0) ? CalculateHeuristic(TargetX, TargetY, Gm, TopTile)  :int.MAX_VALUE;
		var BtmH:int    = (BtmTile   != null && (BtmTile.m_Flag   & Tile.CLOSED) == 0) ? CalculateHeuristic(TargetX, TargetY, Gm, BtmTile)  :int.MAX_VALUE;
		
		//Now we select a new direction, and try to not select the direction we came from:
		//We systimatically choose the lowest cost direction, since any invalid tile has the value of int.MAX_VALUE we are able to find out the best direction by always doing a < comparison.
		if (Direction == DIR_LEFT)       return (LeftH  < TopH   ? (LeftH  < BtmH   ? DIR_LEFT   : DIR_DOWN)  : (TopH   < BtmH)   ? DIR_UP    : (BtmH   != int.MAX_VALUE? DIR_DOWN  : DIR_RIGHT));
		else if (Direction == DIR_UP)    return (TopH   < RightH ? (TopH   < LeftH  ? DIR_UP     : DIR_LEFT)  : (RightH < LeftH)  ? DIR_RIGHT : (LeftH  != int.MAX_VALUE? DIR_LEFT  : DIR_DOWN));
		else if (Direction == DIR_RIGHT) return (RightH < BtmH   ? (RightH < TopH   ? DIR_RIGHT  : DIR_UP)    : (BtmH   < TopH)   ? DIR_DOWN  : (TopH   != int.MAX_VALUE? DIR_UP    : DIR_LEFT));
		else                             return (BtmH   < LeftH  ? (BtmH   < RightH ? DIR_DOWN   : DIR_RIGHT) : (LeftH  < RightH) ? DIR_LEFT  : (RightH != int.MAX_VALUE? DIR_RIGHT : DIR_UP));
	}
}

public class Game{
	...
	public static const InitialLives:int = 3; //The initial lives available for the player.
	...
	public var m_LifeCounter:int; //Lives available.

	public function Update(s:stage):Boolean{
		...else if((m_Units[i].m_State & Unit.GHOST_DEAD)==0) m_Units[0].m_State|=Unit.UNIT_DEAD; //Modify into:
		else if ((m_Units[i].m_State & Unit.GHOST_DEAD) == 0) {
			if ((m_Units[0].m_State & Unit.UNIT_DEAD) == 0) m_LifeCounter--; //Remove life if the player has yet to be considered dead.
			m_Units[0].m_State |= Unit.UNIT_DEAD;
		}
		...if(m_Finished) ResetPlayer(); //Modify into:
		if(m_Finished){
			if (m_LifeCounter == 0) return true; //If no more lives to give, we're dead.
			ResetPlayer();
		}
	}

	//Reset the game.
	public function ResetGame():void {
		ResetPellets(); //Reset Pellets.
		ResetPlayer(); //Reset Player
		m_LifeCounter = InitialLives; //Set life counter.
		return;
	}
	
	public function Game(s:Sprite):void{
		...m_Units[1] = new Unit(m_Tiles[GhostPreSpawnTile], this, new Ghost_Orange()); //Add after this line:

		m_Units[2] = new Unit(m_Tiles[GhostPreSpawnTile], this, new Ghost_Red());
		m_Units[3] = new Unit(m_Tiles[GhostPreSpawnTile], this, new Ghost_Cyan());
		m_Units[4] = new Unit(m_Tiles[GhostPreSpawnTile], this, new Ghost_Purple());
		
		...Remove the following:
			ResetPellets(); //Setup pellets!
			ResetPlayer(); //Setup the player.
			...In their place, place:
		ResetGame();
	}
}

public class Main{

	public function UpdateFunc(E:Event):void{
		...m_Game.Update(stage); //Modify into:
		if (m_Game.Update(stage)) m_Game.ResetGame();
	}
};

• Is the article generally formatted to match our site standards?
• Is the article both game development related and NOT designed to promote a particular product?
• Does the article use appropriate tags?  Tagging is VERY important
• Does the article include a 250x150 pixel image?  If not, create one or put a 250x150 pixel white placeholder image in its place.   Send a message to either Drew Sikora or Michael Tanczos and we will create the image for you.

Introduction

• Utilize a multi-dimensional array to store a game board "map"
• Draw the game screen using data stored in a multi-dimensional array "map"
• React to keyboard input : Allow players to rotate tetrominoes
• Detect collisions with both the side of the game board as well as other pieces
• Detect and remove cleared lines (and possibly update a score table)

Note:  While this project utilizes C# and XNA it is certainly possible to extend the logic shown in the code sections to other platforms

Making the Game

The Pieces

This..	.. can be represented like this using a multidimensional array
	int[,] block = new int[3, 3] {     {0, 1, 0},     {1, 1, 1},     {0, 0, 0} };

List<int[,]> pieces;

pieces = new List<int[,]>();

/* I Piece */
pieces.Add(new int[4, 4] { 
    {0, 0, 0, 0},
    {1, 1, 1, 1},
    {0, 0, 0, 0},
    {0, 0, 0, 0}
});

/* J Piece */
pieces.Add(new int[3, 3] { 
    {0, 0, 1},
    {1, 1, 1},
    {0, 0, 0}
});

/* O Piece */
pieces.Add(new int[2, 2] { 
    {1, 1},
    {1, 1}
});

/* S Piece */
pieces.Add(new int[3, 3] { 
    {0, 1, 1},
    {1, 1, 0},
    {0, 0, 0}
});


/* T Piece */
pieces.Add(new int[3, 3] { 
    {0, 1, 0},
    {1, 1, 1},
    {0, 0, 0}
});

/* Z Piece */
pieces.Add(new int[3, 3] { 
    {1, 1, 0},
    {0, 1, 1},
    {0, 0, 0}
});

        Color[] TetronimoColors = {
                                    Color.Transparent,  /* 0 */
                                    Color.Orange,       /* 1 */
                                    Color.Blue,         /* 2 */
                                    Color.Red,          /* 3 */
                                    Color.LightSkyBlue, /* 4 */
                                    Color.Yellow,       /* 5 */
                                    Color.Magenta,      /* 6 */
                                    Color.LimeGreen     /* 7 */
                                  };

The Game Board (aka Playing Field, Matrix, Grid)

const int BoardWidth = 10;  // Board width in blocks
const int BoardHeight = 20; // Board height in blocks
const int BlockSize = 20;   // Block size in pixels

int[,] Board;
Vector2 BoardLocation = Vector2.Zero;

Board = new int[BoardWidth, BoardHeight];  // Initialize the board

// Reset all board grid locations to empty.. technically they are initialized 
// to zero but this is for demonstration purposes
for (int y = 0; y < BoardHeight; y++)
    for (int x = 0; x < BoardWidth; x++)
    {
        board[x, y] = 0;
    }

0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0

0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0
1, 0, 0, 0, 0, 0, 0, 3, 3, 1
1, 0, 0, 5, 5, 5, 0, 3, 3, 1
1, 0, 3, 3, 5, 4, 4, 0, 2, 1
1, 0, 3, 3, 4, 4, 2, 2, 2, 1

spriteBatch.Begin();

// Draw the board first
for (int y = 0; y < BoardHeight; y++)
    for (int x = 0; x < BoardWidth; x++)
{
    Color tintColor = TetronimoColors[Board[x, y]];
    
    // Since for the board itself background colors are transparent, we'll go ahead and give this one
    // a custom color.  This can be omitted if you draw a background image underneath your board
    if (Board[x, y] == 0)
        tintColor = Color.FromNonPremultiplied(50, 50, 50, 50);
    
    spriteBatch.Draw(spriteSheet, 
                     new Rectangle((int)BoardLocation.X + x * BlockSize, 
                                   (int)BoardLocation.Y + y * BlockSize, 
                                   BlockSize, 
                                   BlockSize), 
                     new Rectangle(0, 0, 32, 32), 
                     tintColor);
}

// ...  SNIP!  Removed code to draw the falling piece
    
spriteBatch.End();

The Falling Piece

int[,] SpawnedPiece;
Vector2 SpawnedPieceLocation;

        // Create a new piece
        public void SpawnPiece()
        {            
            int colr = rand.Next(0, pieces.Count);  // rand is initialized earlier and has the type "Random"

            SpawnedPiece = (int[,])pieces[colr].Clone();  // Make a copy of the piece

            int dim = SpawnedPiece.GetLength(0); // Get the dimension of the first row

            // Colorize the piece by multiplying it by a scalar representing the color
            // In this case, the index for the pieces List is also the same index used for the tintColors
            // array  
            for (int x = 0; x < dim; x++)
                for (int y = 0; y < dim; y++)
                    SpawnedPiece[x, y] *= (colr + 1);

            SpawnedPieceLocation = Vector2.Zero; // Temporary
        }

1.     Accept user input
2.     Determine a new block orientation and location based off of user input
3.     Check to see if we can perform the operation
4.     If yes, commit it
5.     If no, then do nothing

    

// Defined outside of the current class
public enum PlaceStates
{
    CAN_PLACE,
    BLOCKED,
    OFFSCREEN
}

...

// Checks to see if piece can be placed at location x,y on the board
// Returns PlaceStates.CAN_PLACE if it can exist there, otherwise reports a reason why it cannot
public PlaceStates CanPlace(int[,] board, int[,] piece, int x, int y)
{
    // First we'll need to know the dimensions of the piece
    // Since they are square it is sufficient to just get the dimension of the first row
    int dim = piece.GetLength(0);
    
    // All pieces are square, so let's use a nested loop to iterate through all the cells of the piece
    for (int px = 0; px < dim; px++)
        for (int py = 0; py < dim; py++)
    {
        // Calculate where on the game board this segment should be placed
        int coordx = x + px;
        int coordy = y + py;
        
        // Is this space empty?
        if (piece[px, py] != 0)
        {
            // If the board location would be too far to the left or right then
            // we are hitting a wall
            if (coordx < 0 || coordx >= BoardWidth)
                return PlaceStates.OFFSCREEN;
            
            // If even one segment can't be placed because it is being blocked then
            // we need to return the BLOCKED state
            if (coordy >= BoardHeight || board[coordx, coordy] != 0)
            {
                return PlaceStates.BLOCKED;
            }
        }
    }
    
    // If we get this far we can place the piece!
    return PlaceStates.CAN_PLACE;
    
}

// Check to see if there are any already completed lines on the board, if yes remove them
public void RemoveCompleteLines(int[,] board)
{
    // Start at the bottom of the board and work our way up
    for (int y = BoardHeight - 1; y >= 0; y--)
    {
        // Check to see if the line on row y is complete (non-zero)
        bool isComplete = true;
        for (int x = 0; x < BoardWidth; x++)
        {
            if (board[x, y] == 0)
            {
                isComplete = false;
            }
        }
        
        
        if (isComplete)
        {
            // Row y needs to go bye bye
            // Copy row y-1 to row y
            for (int yc = y; yc > 0; yc--)
            {
                for (int x = 0; x < 10; x++)
                {
                    board[x, yc] = board[x, yc - 1];
                }
            }
            
            // Recheck this row
            y++;
            
            // Score += 100;
        }
    }
}


// Permanently write piece to the game board 
// Note that this method assumes that the piece can actually be placed already and does not recheck
// to make sure the piece can be placed
public void Place(int[,] board, int[,] piece, int x, int y)
{
    int dim = piece.GetLength(0);
    
    for (int px = 0; px < dim; px++)
        for (int py = 0; py < dim; py++)
    {
        int coordx = x + px;
        int coordy = y + py;
        
        if (piece[px, py] != 0)
        {
            board[coordx, coordy] = piece[px, py];
        }
        
    }
    
    RemoveCompleteLines(board);
    
}

// Rotate the piece (this style of rotation for Tetris is called a super rotation as it doesn't follow the conventional
// style of piece rotations)
public int[,] Rotate(int[,] piece, bool left)
{
    int dim = piece.GetLength(0);
    int[,] npiece = new int[dim, dim];
    
    for (int i = 0; i < dim; i++)
        for (int j = 0; j < dim; j++)
    {
        if (left)
            npiece[j, i] = piece[i, dim - 1 - j];
        else
            npiece[j, i] = piece[dim - 1 - i, j];
    }
    
    return npiece;
}

{1, 1, 0}     {0, 0, 1}     {0, 0, 0}     {0, 1, 0}
{0, 1, 1}     {0, 1, 1}     {1, 1, 0}     {1, 1, 0}
{0, 0, 0}     {0, 1, 0}     {0, 1, 1}     {1, 0, 0}

Let the Blocks Fall!

        int StepTime = 300;  // Time step between updates in ms
        int ElapsedTime = 0;  // Total elapsed time since the last update
        int KeyBoardElapsedTime = 0;  // Total elapsed time since handling the last keypress

        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            ElapsedTime += gameTime.ElapsedGameTime.Milliseconds;
            KeyBoardElapsedTime += gameTime.ElapsedGameTime.Milliseconds;

            /* SNIP! Keyboard handling code removed */

            // If the accumulated time over the last couple Update() method calls exceeds our StepTime variable
            if (ElapsedTime > StepTime)
            {
                // Create a new location for this spawned piece to go to on the next update
                Vector2 NewSpawnedPieceLocation = SpawnedPieceLocation + new Vector2(0, 1);

                // Now check to see if we can place the piece at that new location
                PlaceStates ps = CanPlace(Board, SpawnedPiece, (int)NewSpawnedPieceLocation.X, (int)NewSpawnedPieceLocation.Y);
                if (ps != PlaceStates.CAN_PLACE)
                {
                    // We can't move down any further, so place the piece where it is currently
                    Place(Board, SpawnedPiece, (int)SpawnedPieceLocation.X, (int)SpawnedPieceLocation.Y);
                    SpawnPiece();

                    // This is just a check to see if the newly spawned piece is already blocked, in which case the 
                    // game is over
                    ps = CanPlace(Board, SpawnedPiece, (int)SpawnedPieceLocation.X, (int)SpawnedPieceLocation.Y);
                    if (ps == PlaceStates.BLOCKED)
                    {
                        // Game over.. normally we would change a game state variable but for this tutorial we're just
                        // going to exit the app
                        this.Exit();
                    }
                }
                else
                {
                    // We can move our piece into the new location, so update the existing piece location
                    SpawnedPieceLocation = NewSpawnedPieceLocation;
                }

                ElapsedTime = 0;
            }

            base.Update(gameTime);
        }

			KeyboardState ks = Keyboard.GetState();

            if (KeyBoardElapsedTime > 200)
            {
                if (ks.IsKeyDown(Keys.Left) || ks.IsKeyDown(Keys.Right))
                {
                    // Create a new location that contains where we WANT to move the piece
                    Vector2 NewSpawnedPieceLocation = SpawnedPieceLocation + new Vector2(ks.IsKeyDown(Keys.Left) ? -1 : 1, 0);

                    // Next, check to see if we can actually place the piece there
                    PlaceStates ps = CanPlace(Board, SpawnedPiece, (int)NewSpawnedPieceLocation.X, (int)NewSpawnedPieceLocation.Y);
                    if (ps == PlaceStates.CAN_PLACE)
                    {
                        SpawnedPieceLocation = NewSpawnedPieceLocation;
                    }

                    KeyBoardElapsedTime = 0;
                }

                if (ks.IsKeyDown(Keys.Up))
                {
                    int[,] newSpawnedPiece = Rotate(SpawnedPiece, true);

                    PlaceStates ps = CanPlace(Board, newSpawnedPiece, (int)SpawnedPieceLocation.X, (int)SpawnedPieceLocation.Y);
                    if (ps == PlaceStates.CAN_PLACE)
                    {
                        SpawnedPiece = newSpawnedPiece;
                    }

                    KeyBoardElapsedTime = 0;
                }


                if (ks.IsKeyDown(Keys.Down))
                {
                    ElapsedTime = StepTime + 1;
                    KeyBoardElapsedTime = 175;
                }
            }

Putting it all Together

spriteBatch.Begin();

// Draw the board first
for (int y = 0; y < BoardHeight; y++)
    for (int x = 0; x < BoardWidth; x++)
{
    Color tintColor = TetronimoColors[Board[x, y]];
    
    // Since for the board itself background colors are transparent, we'll go ahead and give this one
    // a custom color.  This can be omitted if you draw a background image underneath your board
    if (Board[x, y] == 0)
        tintColor = Color.FromNonPremultiplied(50, 50, 50, 50);
    
    spriteBatch.Draw(spriteSheet, 
                     new Rectangle((int)BoardLocation.X + x * BlockSize, 
                                   (int)BoardLocation.Y + y * BlockSize, 
                                   BlockSize, 
                                   BlockSize), 
                     new Rectangle(0, 0, 32, 32), 
                     tintColor);
}

            // Next draw the spawned piece
            int dim = SpawnedPiece.GetLength(0);
            
            for (int y = 0; y < dim; y++)
                for (int x = 0; x < dim; x++)
                {
                    if (SpawnedPiece[x, y] != 0)
                    {
                        Color tintColor = TetronimoColors[SpawnedPiece[x, y]]; 

                        spriteBatch.Draw(spriteSheet, 
                                         new Rectangle((int)BoardLocation.X + ((int)SpawnedPieceLocation.X + x) * BlockSize, 
                                                       (int)BoardLocation.Y + ((int)SpawnedPieceLocation.Y + y) * BlockSize, 
                                                       BlockSize, 
                                                       BlockSize), 
                                         new Rectangle(0, 0, 32, 32), 
                                         tintColor);                      
                    }
                }
    
spriteBatch.End();

Conclusion

Article Update Log

Dominoze

• Integrate only third-party libraries that are completely free to use, and do so with as few libraries as possible. I wanted to develop the game on a $0 code budget (except for purchasing Visual Studio and some other development-related tools), and to do as much of the programming as possible because that's what I love to do.
• Work alone to maximize control and flexibility of the project; and to see if I could pull it off as the only developer. This was a largely ego-based decision.
• Don't study other successful games to understand how they worked. I wanted to be as original as possible, and would not tolerate saying "I was inspired by to make my game" or even "I studied to make mine better."
• Don't quit my day job; keep game development casual.
• Develop features on a need-to basis; no need to write out a design document at the beginning.
• Don't worry about marketing. I'll do that when the game is almost done.
• Don't maintain a developer journal, blog, or regularly network with other game developers. I didn't want to go public until I at least had a playable demo or something close to it; and maintaining those things was a distraction from programming.

The glAppGrapher "graphical server" application

The Dominoze Editor

Dominoze Game Play -- Rotating Stairs Before Moving Them

[url=http://www.gamieon.com/blogimages/dmscreens/1.png]

Dominoze Light Mapped Scene

• It would never reach its real potential if I continued to approach it as a casual hobbyist and not as a committed game developer.
• I'm done maintaining game engines.
• There were easily hundreds of undiscovered bugs that I had no desire to spend hours and days hunting down any more.
• I let the increasing demands of my full time job, combined with game development, turn me into a development machine with a lacking social life. I needed to break out.
• Dominoze is only supported on Microsoft Windows whereas cross-platform games; which I've always wanted to develop anyway, were flourishing.

• If you want to tinker around and develop a game or an engine at a casual pace, then go knock yourself out. When it just goes on forever, or it stops being fun, or you're tired of seeing other developers accomplish far more in less time, then remember this: You did what you wanted to do, and you got exactly what you asked for. Stop doing it, and reassess your goals if you must.
• When you're developing a puzzle game, all things related to user interaction must always come first. Keep other things like the background artwork simple.
• Don't reinvent any wheels unless you plan to upgrade them into spheres.
• Set limitations on yourself. Decide the project must be done in X months. Decide there will be between Y and Z levels, and don't be afraid to narrow things down along the way.
• Even if you want to do all the work yourself, your chances of a successful release will increase if you set aside time maintaining a news feed and blog for your project early on. More exposure time means more new readers, and more of a chance for big media sources to take notice and write about your game.
• Open yourself to continuous feedback during the entire life cycle of the project.
• Let your game grow in release increments; don't do everything in the first release. Don't throw in every feature but the kitchen sink just because you think a first impression of your game is important.

• Development tools: Microsoft Visual Studio, Visual SourceSafe (code repository), Trac (bug tracker), MS Paint, GIMP, Adobe Premiere Elements for video productions, and my old and still functional copy of 3DSMax 3.1 for modeling.
• Video content: Contracted (see Special Thanks section)
• Audio content: Contracted (see Special Thanks section)
• Music: Donated by Mick Rippon!
• Programming language: C/C++
• Foundation libraries: GLUT for the game, Microsoft Foundation Classes for the editor.
• Video engine core: OpenGL
• Audio engine core: OpenAL
• Physics engine core: Newton
• Scripting engine core: LuaScript
• Lines of code for Dominoze-specific libraries and Editor: 216,000 (including code generated from Visual Studio), 49,000 lines of comments*
• Lines of code for the Gamieon-specific engine (designed to be used in other unmanaged projects): 18,800 lines of source code, 5,000 lines of comments*
• Number of dedicated team members: 1
• Number of contracted team members spanning the project's lifetime: 8

• Total monetary costs: ~$10,000 spanning 9 years
• Costs in order of size: Asset purchases, business expenses, hardware, website hosting and development tools.
• Number of development hours: I can't even estimate them. I never kept rigorous track of time, so lets just say A LOT.

• Work with a team that shares my passion for the idea.
• Find other sandbox apps where you just build or create stuff, and study everything about them to learn what to do right and what to avoid.
• Gradually add new features in later releases over time instead of trying to get every great idea in at the beginning.
• Create a plan and set goals and limitations which include a hard release deadline, milestones, a detailed feature list for the release and an idea box for future releases, a budget, and ways to gauge how successful it can be so I know I'll get a return on the investment.
• As much as I love programming, it sure would be nice to at least monetarily break even with all that I put into it.
• Get myself and this project more involved with the development and gaming community in general. I've enjoyed countless quiet evenings of programming freely; but I've had quite my share of them.

// Hello World!.cpp : Defines the entry point for the console application.

//

#include "stdafx.h"

int _tmain(int argc, _TCHAR* argv[])

{

   return 0;

}

// Hello World!.cpp : Defines the entry point for the console application.

//

int main()

{

   return 0;

}

#include <iostream>

// Hello World!.cpp : Defines the entry point for the console application.

//

#include <iostream>

int main()

{

   return 0;

}

std::cout << "Hello World!" << std::endl;

std::cin.get();

// Hello World!.cpp : Defines the entry point for the console application.
//

#include <iostream>

int main()

{

   std::cout << "Hello World!" << std::endl;

   std::cin.get();

   return 0;

}

Questions

Answer: replace the #include statement with the code located in the filename

Answer: The preprocessor runs through your code before compiling and readies it for compiling

Answer: wait for user input

Answer: Prints to the console

Answer: Inserts data into cout

Answer: End the current line in the console

Coming Next Lesson:

• Variables!
• Main Function!
• Console Input / Output!

Article Change-Log!

• Removed

  using namespace std;

  command!
• Changed _tmain() to main() and explained main()!
• Fixed last source code!
• Clarified Left-Shift Operator!
• Fixed Source Code!
• Clarified the purpose of SemiColons!
• Fixed more Source Code!
• Removed #include "stdafx.h"!

// Hello World!.cpp : Defines the entry point for the console application.

//

#include <iostream>

int main()
{

   std::cout << "Hello World!" << std::endl;

   std::cin.get();

   return 0;

}

returnType functionName(function Parameter)
{
 Code!
}

return value;

variableType variableName = variableValue;

    
    bool (stands for boolean): Can be either true or false.
    byte: Can contain any number between -127 and 127 (No Decimals).
    short: Smaller (Shorter) version of integer (No Decimals).
    char: Contains a single character. Can contain a large amount of different characters.
    int: The basic Integer. Can contain a very large integer (No Decimals).
    long: Largest type of integer. Can contain very small and high values (No Decimals).
    float: Can contain very large floating-point numbers (Decimals).
    double: Can contain extremely large floating-point numbers (Decimals).
    

int number = 27;
char firstLetterOfAlphabet = 'a';

// Hello World!.cpp : Defines the entry point for the console application.
//

#include <iostream>

int main()
{
   int number = 27;
   char firstLetterOfAlphabet = 'a';

   std::cout << number << firstLetterOfAlphabet << std::endl;
   std::cin.get();
   return 0;
}

int number;
number = 27;

int number = 27;

int number = 30, otherNumber = 56;

int number = 30, char character = 'a';

Operators

    

+	adds two numbers
-	subtracts two numbers
*	multiplies two numbers
/	divides two numbers
%	gives the remainder of two numbers

op1 (operator) op2;

number = 27;
otherNumber = 30;
result = number + otherNumber;

// Hello World!.cpp : Defines the entry point for the console application.
//

#include <iostream>

int main()
{
   int number = 27;
   int otherNumber = 30;
   int result = number + otherNumber;

   std::cout << result << std::endl;
   std::cin.get();

   return 0;
}

auto number = 27;

auto number;
number = 17;

Questions

Answer: A symbol attached to a value

Answer: They allow us to store data

Answer: *

Answer: to assign it a value for the first time

Answer: Using cout, separating the variables we would like to print out with the insertion operator

Coming in next tutorial: Console Input and Output!

• Fixed formatting!
• Synchronized Code!

Vector Math in Games

Concepts

Note:  In the world of programming programmers have utilized the vector type to represent both vectors in the traditional mathematical/physics sense as well as points or arbitrary n-tuplet units at their own discretion.  Be advised.

• Position - a vector represents an offset from your world origin point (0, 0, 0).
• Direction - vector looks very much like an arrow pointing at some direction. That is indeed what it can be used for. For example, if you have a vector that points south, you can make all your units go south.
• A special case of direction vector is a vector of length 1. It is called a normalized vector, or normal for short.
• A velocity vector can describe a movement. In that case, it is a difference in position over specific amount of time.

Remember the Basics - Vector Addition and Subtraction

Example: a Distance Between Objects

tree_position = (10, 10, 0)
my_position = (3, 3, 0)
# distance and direction you would need to move 
# to get exactly where the tree is
vector_to_tree = tree_position - my_position

Example: Velocity

position = (0, 10, 10) # position: 10 units in Y and Z direction
velocity = (500, 0, 0) # initial movement is 500 units in X direction over the next second

position += velocity # add velocity to position and update position

Concept: Simulation

position += velocity * delta

Example: Gravity, Air Resistance and Wind

# increase velocity of every object -2 down per second
gravity_vector = (0, -2, 0)

velocity += gravity_vector * delta # apply gravity effect
position += velocity * delta # update position

velocity += gravity_vector * delta # apply gravity effect
velocity *= 0.5 * delta # apply 0.5 slowdown per second
    
position += velocity * delta # update position

# modify kinetic energy / velocity
velocity += gravity_vector * delta # apply gravity effect
velocity *= 0.5 * delta # apply 0.5 slowdown per second
    
# add all forces
final_change_per_second = velocity + wind_force_per_second
    
# update position
position += final_change_per_second * delta

Concept: Direction

final_change = (B - A).normalize() * 3

Concept: Surface Plane

Concept: Dot Product

result = A dot B

• If dot product is 1, normals face the same direction.
• If dot product is 0, normals are perpendicular.
• If dot product is -1, normals face opposite directions.

angle = acos(A dot B)

Example: Light

• A normal vector which represent the direction of surface at this point.
• Position of the light.
• Position of this surface point.

distance_vec = light_pos - point_pos

light_direction = distance_vec.normalize()

brightness = surface_normal dot light_direction

varying vec3 surface_normal;
varying vec3 vertex_to_light_vector;

void main(void)
{
vec4 diffuse_color = vec3(1.0, 1.0, 1.0); // the color of surface - white
float diffuse_term = dot(surface_normal, normalize(vertex_to_light_vector));
gl_FragColor = diffuse_color * diffuse_term;
}

Example: Distance from a point to a plane

distance_to_a_plane = (point - plane_point) dot plane_normal;

Example: Is a point on a plane?

Example: Is a vector parallel to a plane?

Example: Line intersection with a plane

dot1 = SN dot (SP - P1)
dot2 = SN dot (P2 - P1)

u = (SN dot (SP - P1)) / (SN dot (P2 - P1))

• if u == 0, line is parallel the plane.
• if u <= 1 and u > 0, line intersects the plane.
• if u > 1, no intersection.

intersection point = (P2 - P1) * u

Concept: Cross Product

Example: Collision

temp_vector = change cross plane_normal

new_direction = temp_vector cross plane_normal

new_direction = (change cross plane_normal) cross plane_normal

Now what?

More in-depth reading

• Vector Math - Addition, subtraction, negation, normalization.
• Better Explained Dot Product - Follows similar style of explaining dot product by examples
• Dot Product and Cross Product - More in-depth explanation of dot and cross products
• What is a game loop? - Short explanation of the game loop
• More in-depth look at the different update loop types

I have a really iterative design

I don't really pre-visualize, I try to sort out more details at implementation

• Performance is important; input lag is a bad thing.
• It should be easy to have new systems tap into the input stream.
• The system must be very flexible and capable of handling a wide variety of game situations.
• Configurability (input mapping) is essential for modern games.

• Raw input gathering from the OS/etc.
• Input mapping and dispatch to the correct high-level handlers
• High level handler code

• Actions
• States
• Ranges

• Every frame, raw input is obtained from the OS/hardware
• The currently active contexts are evaluated, and input mapping is performed
• Once a list of actions, states, and ranges is obtained, we package this up into a special data structure and invoke the appropriate callbacks

• The first layer gathers raw input data from the hardware, and optionally normalizes ranged inputs
• The second layer examines what game contexts are active, and maps the raw inputs into high-level actions, states, and ranges. These are then passed on to a series of callbacks
• The third layer receives the callbacks and processes the input in priority order, performing game activity as needed

• rawinputconstants.h (a code file) specifies a series of ID codes, usually in an enumeration, corresponding to each raw input (from hardware) that we might handle. These are divided up into "buttons" and "axes." Buttons can map to states or actions, and axes always map to ranges.

• inputconstants.h (a code file) specifies another set of ID codes, this time defining each action, state, and range available in the game.

• contexts.xml (a data file) specifies each context in the game, and provides a list of what inputs are valid in each individual context.

• inputmap.xml (a data file) carries one section per context. Each context section lists out what raw input IDs are mapped to what high-level action/state/range IDs. This file also holds sensitivity configurations for ranged inputs.

• inputranges.xml (a data file) lists each range ID, its raw value range (say, -100 to 100), and how to map this onto a normalized internal value range (such as -1 to 1).

• A code class called RangeConversions loads inputranges.xml and handles converting a raw value to a mapped value.

• A code class called InputContext encapsulates all of the functionality of mapping a single context worth of inputs from raw to high-level IDs, including ranges. Sensitivity configurations are applied here. This class basically just exists to act on the data from inputmap.xml.

• A code class called InputMapper encapsulates the process of holding a list of valid (active) InputContexts. Input is passed into this class from the first-layer code, and out into the third-layer code.

• A code class (usually a POD struct in C++ versions of the system) called MappedInput holds a list of all the input mapped in the current frame, as covered above.

• Each frame (or whenever input is available), the first layer of input code takes all of the available input and packs it into an InputMapper object. Once this is finished, it calls InputMapper.Dispatch() and the InputMapper then calls InputContext.MapInput() for each active context and input. Once the final list of mapped input is compiled into a MappedInput object, the MappedInput is passed into each registered callback, and the high-level game code gets a chance to react to the input.

Introduction

Your First Step to Game Development Starts Here

You've learned a language. Skills are at the ready. Now it's time to finally create that game! After years of playing games and discussing graphics, design, and mechanics, the time to put the game that has been dreamt about on the big screen is now. That Final Fantasy 7 remake is the first game that needs to be made. The idea of making it an online multiplayer is also a priority. Why? It would make the game better of course. Plus, everyone wants that feature anyway. Now the googling begins. What engine was it made from? What graphics does it need? Did it use DirectX or OpenGL or even Unity? Every new question produces two more questions. It gets to the point that the tasks and goal  can be overwhelming. But with ambition the goal can be met! Right? Unfortunately as many beginners come to find out, the complexity of a game can tamper ambition and in some cases completely put out the flame. However, this article will help you prevent that and also build up your game programming skills.

But first let's address some issues that a vast majority of beginners run into.

Many beginners ask what language they should be using. The answer is this: any language. Yes, that's right: C, C++, D, Java, Python, Lua, Scheme, or F#. And that's the short list. The language is just a tool. Using one language or the other does not matter. Don't worry about what the professionals are using. As a beginner, the only priority and goal is having the tools to create and complete the game. The second priority is to improve your code and skill. We'll get into that a bit later. Remember there is no "which language is better?" or "which language is best?". The only question anyone with experience will ask is: "How much experience do you have with the language?". At this stage in the game development journey, familiarity and skill with whatever language you are using is more important than the language itself. This is an universal truth.

With your language of choice in hand, now is the time to choose how you will  make the game. The choice normally is among a game development library,  game engine, or a game maker. Which should you choose? If you are prototyping or are not a programmer, then a game maker would probably be the best choice. However game makers (ex: Game Maker, RPG Maker, ENIGMA) are able to create games (which I list later on) similar to the games of the 8-bit and 16-bit era. Game makers do some of the heavy lifting for you (ex: loading/handling image formats, input handling, integrating physics) and allow you to focus on the game itself. Most, if not all, game makers have an language specific to it to handle more advanced techniques and situations. The language more often than not is similar to C/C++/Javascript. Game engines such as Unreal, Crysis, and Unity handle all manner of games (ex: 2D, 3D, offline, online) and therefore are far more complex and in some cases complete overkill for the type of games a beginner should be making. Game engines should be used when you as a game developer have a several games under your belt and fully understand the mechanics of making a game. For most beginner game developers, especially those who are programmers, choosing a game development library is a good choice. It puts those programming skills to the test and allows discovery of more things about the language. Like the language, the library doesn't matter. Whether it's SDL, SFML, PyGame (for Python only), or Allegro, the library is just another tool to create and complete the game. Game dev libraries have more or less the same features. So whichever you pick will be fine to get the job done.

Finally after gathering our tools: language and game dev library or game maker software, we are ready to answer the most important question of all. "What game should I make?" For this question, the answer has to be approachable, doable, and for the most part understood. This is why the game that should be made should be 2D. Everyone understands 2D games. 2D games can be fancy but at its core they are basic with very few "moving parts".

Believe it or not, the previous question has a definitive answer. And that answer is Pong. Now you may wonder, "why?". Well, Pong is one of the simplest games known. The graphics are simple and the mechanics are simple. There's no guesswork on how Pong should work. Therefore it's the best candidate for the first game to be made. Each new game that is presented in this article is meant to show something new and/or build upon what the last game taught you. The skills that are learned from each game become cumulative and not specific to just one game. So each game is a step up in terms of difficulty, but nothing a little brainpower and some brute force can't solve.
Now I'll list some well-known games that will definitely help your game development skills and allow you to have actual complete games under your belt. I'll quickly point out some things that will be learned for each game. These games are:

• Pong = Simple: input, physics, collision detection, sound; scoring
• Worm = Placement of random powerups, handling of screen boundaries, worm data structure
• Breakout = Lessons of pong, powerups, maps (brick arrangements)
• Missile Command = targeting; simple enemy ai, movement, and sound
• Space Invaders = simple movement for player and enemy, very similar to breakout with the exception that the enemy constantly moves downward, simple sound
• Asteroids = asteroids (enemies) and player can move in all directions, asteroids appear and move randomly, simple sound
• Tetris = block design, clearing the lines, scoring, simple animation
• Pac Man = simple animation, input, collision detection, maps (level design), ai
• Ikari Warriors = top down view, enemy ai, powerups, scoring, collision detection, maps (level design), input, sound, boss ai
• Super Mario Bros = lessons of Ikari Warriors (except with side-view instead of top-down view), acceleration, jumping, platforms

The list shows games in terms of difficulty from least to greatest as far as programming them goes. There are games that others may suggest but these 10 games will definitely round out what you need to know in 2D game development. If you can make and complete these games, then games like Sonic, Metroid, or even Zelda become that much easier. Those games are just variations or extensions of what you have already learned.

Before I end this article, I would like to say something about completing the games. As I said above, your primary goal is making and completing the game. However, your secondary, and arguably just as important, goal is to refine your game. It's safe to say that 99% of programmers do not code Pong perfectly. Most likely your first or even second go around with Pong or Worm will not be a software architecture masterpiece. And it's not supposed to be. However, to improve your code and therefore your skill, you'll have to submit code for a code review. As all will attest to, this is a good thing TM. Allowing others to proofread your code will give you insights on better structure, better practices, and dangerous code that may work now, but may crash in the near or far future. Being introduced to good advice early in your game dev journey will save you from sudden and unnecessary meetings between your head and the keyboard. As you complete one game and move on to the next, do not kick that completed game to the corner. Go back (sooner rather than later) and refactor and improve the code. Doing so is proof that you understand the advice that others are giving you and shows that your skills have indeed become better. So in short, the process of making a game should be: create > complete > code review > refactor. Again, once you submit your code for review go on to the next game on the list, but remember to go back and improve that code after you get some feedback.

If you've made to the end of this article, you now have a path to start your game development journey. This article is meant to be a guide and not a be-all, end-all to game development. Hopefully the advice given here helps others start to become better game developers.

Article Update Log

Introduction

Basics

[x', y', z', w'] = [x, y, z, w] * View

M = View * Projection

[x', y', z', w'] = [x, y, z, w] * View * Projection

Implementation

• position – camera position coordinates in world coordinate system;
• target – camera’s focus target position. Note that this point must lie on the line of look at target vector in picture 3;
• up_direction – camera coordinate system up vector. Usually this is (0, 1, 0), but if we want our camera to be free, we have to track this vector changes by our own;
• radians – the angle between view frustum’s upper plane and bottom plane in radians, projection angle;
• ratio – this is a result of division between projection’s width and height. Usually this is the same as screen_width/screen_height;
• near_plane, far_plane – those parameters define the distance of corresponding clip planes from camera position measured along look-at-target axis;
• view_width, view_height – the width and height of orthogonal frustum.

//GCamera.h
#pragma once
#include "GUtility.h"

namespace Game
{
////////////////////////////////////////////////////////
// Stores View and Projection matrices used by shaders
// to translate 3D world into 2D screen surface
// Camera can be moved and rotated. Also, user can change 
// camera's target and position
////////////////////////////////////////////////////////
class GCamera
{
public:
	// Constructs default camera looking at 0,0,0
	// placed at 0,0,-1 with up vector 0,1,0 (note that mUp is NOT a vector - it's vector's end)
    GCamera(void);
	// Create camera, based on another one
	GCamera(const GCamera& camera);
	// Copy all camera's parameters
    GCamera& operator=(const GCamera& camera);
    ~GCamera(void) {}

private:
	// Initialize camera's View matrix from mPosition, mTarget and mUp coordinates
	void initViewMatrix();

public:
	// Initialize camera's perspective Projection matrix
	void InitProjMatrix(const float angle, const float client_width, const float client_height, 
		const float nearest, const float farthest);
	// Initialize camera's orthogonal projection
	void InitOrthoMatrix(const float client_width, const float client_height,
		const float near_plane, const float far_plane);

	// Resize matrices when window size changes
	void OnResize(uint32_t new_width, uint32_t new_height);

	///////////////////////////////////////////////
	/*** View matrix transformation interfaces ***/
	///////////////////////////////////////////////

	// Move camera
	void Move(XMFLOAT3 direction);
	// Rotate camera around `axis` by `degrees`. Camera's position is a 
	// pivot point of rotation, so it doesn't change
	void Rotate(XMFLOAT3 axis, float degrees);
	// Set camera position coordinates
    void Position(XMFLOAT3& new_position);
	// Get camera position coordinates
	const XMFLOAT3& Position() const { return mPosition; }
	// Change camera target position
	void Target(XMFLOAT3 new_target);
	// Get camera's target position coordinates
	const XMFLOAT3& Target() const { return mTarget; }
	// Get camera's up vector
	const XMFLOAT3 Up() { return GMathVF(GMathFV(mUp) - GMathFV(mPosition)); }
	// Get camera's look at target vector
	const XMFLOAT3 LookAtTarget() { return GMathVF(GMathFV(mTarget) - GMathFV(mPosition)); }	
	// Returns transposed camera's View matrix	
    const XMFLOAT4X4 View() { return GMathMF(XMMatrixTranspose(GMathFM(mView))); }

	/////////////////////////////////////////////////////
	/*** Projection matrix transformation interfaces ***/
	/////////////////////////////////////////////////////

	// Set view frustum's angle
	void Angle(float angle);
	// Get view frustum's angle
	const float& Angle() const { return mAngle; }

	// Set nearest culling plane distance from view frustum's projection plane
	void NearestPlane(float nearest);
	// Set farthest culling plane distance from view frustum's projection plane
	void FarthestPlane(float farthest);

	// Returns transposed camera's Projection matrix
	const XMFLOAT4X4 Proj() { return GMathMF(XMMatrixTranspose(GMathFM(mProj))); }
	// Returns transposed orthogonal camera matrix
	const XMFLOAT4X4 Ortho() { return GMathMF(XMMatrixTranspose(GMathFM(mOrtho))); }

private:
    /*** Camera parameters ***/
    XMFLOAT3 mPosition;		// Camera's coordinates
    XMFLOAT3 mTarget;		// View target's coordinates
    XMFLOAT3 mUp;			// Camera's up vector end coordinates

	/*** Projection parameters ***/
	float mAngle;			// Angle of view frustum
	float mClientWidth;		// Window's width
	float mClientHeight;	// Window's height
	float mNearest;			// Nearest view frustum plane
	float mFarthest;		// Farthest view frustum plane

    XMFLOAT4X4  mView;		// View matrix
	XMFLOAT4X4	mProj;		// Projection matrix
	XMFLOAT4X4	mOrtho;		// Ortho matrix for drawing without tranformation
};

} // namespace Game

//GCamera.cpp
#include "GCamera.h"

namespace Game
{

GCamera::GCamera(void)
{
    mPosition		= XMFLOAT3(0.0f, 0.0f, -1.0f);
    mTarget			= XMFLOAT3(0.0f, 0.0f, 0.0f);
    mUp				= GMathVF(GMathFV(mPosition) + GMathFV(XMFLOAT3(0, 1, 0)));
	this->initViewMatrix();

	mAngle			= 0.0f;
	mClientWidth	= 0.0f;
	mClientHeight	= 0.0f;
	mNearest		= 0.0f;
	mFarthest		= 0.0f;

	XMStoreFloat4x4(&mView, XMMatrixIdentity());
	XMStoreFloat4x4(&mProj, XMMatrixIdentity());
	XMStoreFloat4x4(&mOrtho, XMMatrixIdentity());
}

GCamera::GCamera(const GCamera& camera)
{
	*this = camera;
}

GCamera& GCamera::operator=(const GCamera& camera)
{
    mPosition		= camera.mPosition;
    mTarget			= camera.mTarget;
    mUp				= camera.mUp;

	mAngle			= camera.mAngle;
	mClientWidth	= camera.mClientWidth;
	mClientHeight	= camera.mClientHeight;
	mNearest		= camera.mNearest;
	mFarthest		= camera.mFarthest;

    mView			= camera.mView;
	mProj			= camera.mProj;
	mOrtho			= camera.mOrtho;
    return *this;
}

void GCamera::initViewMatrix()
{
	XMStoreFloat4x4(&mView, XMMatrixLookAtLH(XMLoadFloat3(&mPosition), XMLoadFloat3(&mTarget), 
		XMLoadFloat3(&this->Up())));
}

void GCamera::InitProjMatrix(const float angle, const float client_width, const float client_height, 
								const float near_plane, const float far_plane)
{
	mAngle = angle;
	mClientWidth = client_width;
	mClientHeight = client_height;
	mNearest = near_plane;
	mFarthest = far_plane;
	XMStoreFloat4x4(&mProj, XMMatrixPerspectiveFovLH(angle, client_width/client_height, 
		near_plane, far_plane));
}

void GCamera::Move(XMFLOAT3 direction)
{
	mPosition = GMathVF(XMVector3Transform(GMathFV(mPosition), 
		XMMatrixTranslation(direction.x, direction.y, direction.z)));
	mTarget = GMathVF(XMVector3Transform(GMathFV(mTarget), 
		XMMatrixTranslation(direction.x, direction.y, direction.z)));
	mUp = GMathVF(XMVector3Transform(GMathFV(mUp), 
		XMMatrixTranslation(direction.x, direction.y, direction.z)));

	this->initViewMatrix();
}

void GCamera::Rotate(XMFLOAT3 axis, float degrees)
{
	if (XMVector3Equal(GMathFV(axis), XMVectorZero()) ||
		degrees == 0.0f)
		return;

	// rotate vectors
	XMFLOAT3 look_at_target = GMathVF(GMathFV(mTarget) - GMathFV(mPosition));
	XMFLOAT3 look_at_up = GMathVF(GMathFV(mUp) - GMathFV(mPosition));
	look_at_target = GMathVF(XMVector3Transform(GMathFV(look_at_target), 
		XMMatrixRotationAxis(GMathFV(axis), XMConvertToRadians(degrees))));
	look_at_up = GMathVF(XMVector3Transform(GMathFV(look_at_up), 
		XMMatrixRotationAxis(GMathFV(axis), XMConvertToRadians(degrees))));

	// restore vectors's end points mTarget and mUp from new rotated vectors
	mTarget = GMathVF(GMathFV(mPosition) + GMathFV(look_at_target));
	mUp = GMathVF(GMathFV(mPosition) + GMathFV(look_at_up));

	this->initViewMatrix();
}

void GCamera::Target(XMFLOAT3 new_target)
{
	if (XMVector3Equal(GMathFV(new_target), GMathFV(mPosition)) ||
		XMVector3Equal(GMathFV(new_target), GMathFV(mTarget)))
		return;

	XMFLOAT3 old_look_at_target = GMathVF(GMathFV(mTarget) - GMathFV(mPosition));	
	XMFLOAT3 new_look_at_target = GMathVF(GMathFV(new_target) - GMathFV(mPosition));
	float angle = XMConvertToDegrees(XMVectorGetX(
		XMVector3AngleBetweenNormals(XMVector3Normalize(GMathFV(old_look_at_target)), 
		XMVector3Normalize(GMathFV(new_look_at_target)))));
	if (angle != 0.0f && angle != 360.0f && angle != 180.0f)
	{
		XMVECTOR axis = XMVector3Cross(GMathFV(old_look_at_target), GMathFV(new_look_at_target));
		Rotate(GMathVF(axis), angle);
	}
	mTarget = new_target;
	this->initViewMatrix();
}

// Set camera position
void GCamera::Position(XMFLOAT3& new_position)
{
	XMFLOAT3 move_vector = GMathVF(GMathFV(new_position) - GMathFV(mPosition));
	XMFLOAT3 target = mTarget;
	this->Move(move_vector);
	this->Target(target);
}

void GCamera::Angle(float angle)
{
	mAngle = angle;
	InitProjMatrix(mAngle, mClientWidth, mClientHeight, mNearest, mFarthest);
}

void GCamera::NearestPlane(float nearest)
{
	mNearest = nearest;
	OnResize(mClientWidth, mClientHeight);
}

void GCamera::FarthestPlane(float farthest)
{
	mFarthest = farthest;
	OnResize(mClientWidth, mClientHeight);
}

void GCamera::InitOrthoMatrix(const float clientWidth, const float clientHeight,
		const float nearZ, const float fartherZ)
{
	XMStoreFloat4x4(&mOrtho, XMMatrixOrthographicLH(clientWidth, clientHeight, 0.0f, fartherZ));
}

void GCamera::OnResize(uint32_t new_width, uint32_t new_height)
{
	mClientWidth = new_width;
	mClientHeight = new_height;
	InitProjMatrix(mAngle, static_cast<float>(new_width), static_cast<float>(new_height), mNearest, mFarthest);
	InitOrthoMatrix(static_cast<float>(new_width), static_cast<float>(new_height), 0.0f, mFarthest);
}

}

// GUtility.h
#pragma once
#include <windows.h>

#include <d3d11.h>
#include <directxmath.h>
#include <iostream>

using namespace DirectX;

inline XMVECTOR GMathFV(XMFLOAT3& val)
{
	return XMLoadFloat3(&val);	
}

inline XMFLOAT3 GMathVF(XMVECTOR& vec)
{
	XMFLOAT3 val;
	XMStoreFloat3(&val, vec);
	return val;
}

1. We calculate two vectors – look-at-target vector and up vector.
2. Construct the rotation matrix from passed into function axis and angle by calling XMMatrixRotationAxis(axis, angle).
3. Modify both vectors by this matrix by calling XMMatrixTransform(vector, transform_matrix).
4. Restore the coordinates of target and up end points and recreate camera view matrix. Camera position does not change in rotation.

GCamera camera;
// camera initialization
camera.Rotate(XMFLOAT3(0.0f, 0.0f, 1.0f), 90.0f); // roll by 90 degrees clockwise
// ...
camera.Rotate(XMFLOAT3(1.0f, 0.0f, 0.0f), 90.0f); // pitch by 90 degrees clockwise
// ...
camera.Rotate(XMFLOAT3(0.0f, -1.0f, 0.0f), 90.0f); // yaw by 90 degrees clockwise