We’re going to make a Windows game rather than an Xbox 360 game.
Primarily in order to make the tutorials
accessible to those who don’t have an Xbox.
So go ahead and choose Windows Game (2.0), and select a name for your game.
I prefer to have my projects on the desktop for ease of access,
but the default location is acceptable of course.
Click OK and you should see some code magically appear.

The code you’re looking at is the Game1.cs class.
This is the bones (and the blood and flesh to be honest) of our game.
This is where we will add and display content (sprites, music etc.),
and update the game logic (gameplay, menus etc.)

If you look at the Solution Explorer on the right, you will see a Content subtree.
This, funnily enough, is where we will add our content so our game can access it.
Further down you will see a second C# file, Program.cs.
Double-click on that to open it up. You should see the following code…

using System;

namespace AwesomeGame
{
    static class Program
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        static void Main(string[] args)
        {
            using (Game1 game = new Game1())
            {
                game.Run();
            }
        }
    }
}

You should be able to understand this pretty well…
the statements using System; and namespace AwesomeGame
just indicate that you will be using the System library and that
the contained class or classes will belong to your game AwesomeGame.
The class itself has one method, the main method,
static void Main(string[] args)
You should know that every program has only one main method
and it serves as the entry point, the first section of our program to be evaluted.
The Main method contains the following code…

using (Game1 game = new Game1())
            {
                game.Run();
            }

This just creates a new instance of our game class,
(where we define the behaviour of our game)
and runs it..

Now lets get back to Game1.cs
It’s a bit bigger than the Program class,
so lets break it down into bitesize pieces…

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace AwesomeGame
{

This again should be self-explanatory.
The libraries you need to include to create your game,
and indicating the following class belongs to the namespace AwesomeGame.

public class Game1 : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        public Game1()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

Again, this is pretty simple…
Create a new GraphicsDeviceManager to manage your graphics device (shocked?)
and set the Root Directory, where XNA will start looking for your content
(It is set to the Content folder which is located in your project directory)

protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            // TODO: use this.Content to load your game content here
        }

        /// <summary>
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// </summary>
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>

The comments do a pretty job of explaining the next few methods…
Initialize() is used to set up (initialize) anything we
want initialized (eg variables, behaviour) at the start of our game
LoadContent() is used to get textures, audio etc. from our Content folder(s)
so they can be accessed in our program.
UnloadContent() disposes the content that was loaded by LoadContent()
The comments should clear up any uncertainties.
Let’s move on…

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

            // TODO: Add your update logic here

            base.Update(gameTime);
        }

Update() is where the magic happens.
It is called…er…lots of times every second.
It is where we place our game logic
ie. move objects, change to a different screen, take input etc.

protected override void Draw(GameTime gameTime)
        {
            graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

            // TODO: Add your drawing code here

            base.Draw(gameTime);
        }

You’ve guessed it already haven’t you?
Yes, Draw() is where textures are drawn to the screen.
The statement, graphics.GraphicsDevice.Clear(Color.CornflowerBlue);,
clears the graphics device (which was created way up the top of our class)
and draws our window the colour “CornflowerBlue”.

Now…run the game (press F5)
You should see a CornflowerBlue window.
A bit of an anti-climax, right?
Fortunately we can turn this plain window into something great,
in a relatively short space of time…

Next time I’ll show you how to do something worthwhile.
Stick with me
For now, re-examine the code,
and make sure you understand it at least somewhat.

“The OpenGL Utility Toolkit (GLUT) is a library of utilities for OpenGL programs, which primarily perform system-level I/O with the host operating system. Functions performed include window definition, window control, and monitoring of keyboard and mouse input. Routines for drawing a number of geometric primitives (both in solid and wire-frame mode) are also provided.”

Three cheers for Wikipedia

For those of you who don’t know,
OpenGL is an API for writing 2D and 3D graphics programs.
Many commercial games utilize engines that have been built on top of OpenGL.
Half-Life, Quake, Doom, Unreal Tournament and Star Wars: KOTR
are just a few of the more popular titles…

So, I’m just going to do a quick tutorial on how to use
GLUT and OpenGL to do some basic graphic related tasks…

**A quick word of warning before I start…**

Though OpenGL and GLUT are supported on many different platforms
and can be interfaced with using many different languages,
for simplicity’s sake I’m going to program using C/C++ (stop laughing)
in an Ubuntu Linux environment.
So just note that if you are following the tutorial(‘s?) using a different platform,
I may not be able to help should you run into trouble.
Windows should be OK…but you can forget about Mac…

**Another quick word**

With any programming you do, it’s vital that you are in appropriate surroundings.
No I don’t mean a comfy chair and a good supply of energy drinks.
I mean you should have an organized filesystem,
and most importantly, a good source editor and compiler.
Before you rush to open up the latest IDE with all it’s bells and whistles,
let me say that you’d be best served to use something a bit more simple.
I’ll be using plain old Text Editor on linux…
For Windows I recommend Notepad++ or maybe Crimson Editor

OK. After all that I’m guessing you just want the damn thing running.

For Linux, it couldn’t be easier (well…everything could be easier)
First you need to download the OpenGL and GLUT packages.
You can use your package manager and just mark them for installation.
Alternatively you can download the packages from HERE and HERE
Fortunately the OpenGL library is already pre-installed on Windows.
Getting GLUT to interface with it however, is a different matter entirely.

ARTICLE UNFINISHED…

I don’t have too much experience programming in Windows,
but Wikipedia tells me the .NET framework is included in Windows Vista.
So I assume if you’re running something other than Vista you’ll
have to install it (I’ll leave that up to you…)

Firstly, you need Visual C# 2005 Express
(I’m 90% sure VC#2008 won’t be supported untill XNA 3.0 is released)
You can find Visual C# 2005 Express here.
Install it and then run it so it can perform it’s initial setup.

Next you need the service pack Visual C# 2005 Express SP1
It’s on the same page as the VC#2005 Express download.
Just scroll down to “Step 2: Download Additional Components”,
and click on “Download Visual C# 2005 Express SP1″.
Install it, and run Visual C# 2005 Express.

If you’re running Windows Vista,
you’ll need the “Visual Studio 2005 SP1 Update for Windows Vista”
It’s just a little further down on that same webpage.
When it’s installed, run Visual C# 2005 Express yet again.

Finally you can download XNA Game Studio 2.0
You’ll find it here

By this stage, XNA should be working on your computer.
I’ll get to running it and explaining a few things in Part 2.

I will be creating a series of tutorials to help you create games using XNA..
I’ll start off with the basics : Pong, Breakout, Tetris.
Maybe Pacman and then a basic platformer. We’ll see how it goes…
These will introduce you to many of the concepts that
are fundamental in the design of most games…
After a while we can move on to making basic 3d games.

***NB: Please be aware that you will need at least some
programming experience to follow the tutorials***

For the time being you might want to get XNA up and running,
(I’ll create a tutorial on installing XNA soon)
and play around with it a bit…

Any questions…don’t hesitate to ask

Some useful XNA related websites:

http://creators.xna.com/
http://www.ziggyware.com/
http://www.xnadevelopment.com/
http://www.riemers.net/

So a bit about me first…
I’m from Ireland, 19 years old..
Currently in my second year of a 4 year degree course in University.

The course? Multimedia and Computer Games Development.
It’s a broad course covering many Computer Science related disciplines,
with a particular focus on the design and development of computer games.

While I may have some reservations about how the teaching is organised,
the course thusfar has been a great help to me and will hopefully provide me with
the knowledge and qualifications I need to pursue a career in a related field.
If anybody is interested in computers and has the opportunity to
do a similar course, I really do recommend it…

Anyway…
Because it has only been a little over a year since I was first exposed
to the technical workings that go on inside our computers and
behind the interfaces of our favourite websites and programs,
it has often been a difficult experience.
I often find myself struggling to perform a task, to get a program working,
or to implement a design feature into a program…

As many people do, I turn to Google,
and though it can be helpful, alot of the time
I find myself trying to piece together snippets of information
from dozens of different sources..

So as I solve the problems that arise
I plan to document my work here…
And even though the primary purpose is
to provide one place for myself to refer to,
maybe it can provide some help for others who run into trouble…