Getting started with C#

So, you want to learn C#. It is a good programming language to learn for just about anybody. I will try to guide you through the process. If you are not fortunate enough to own a full copy of Visual Studio, there is an alternative. There are Express Editions that Microsoft has developed. They are free to download and use.

In this tutorial series I will be using Visual C# 2008 Express Edition. There was a 2005 edition but it has been discontinued. Not all of the code will work in Visual C# 2005. It is always a good idea to use the latest version of software anyway.

Tomorrow I will help you get started with C#.

Proud member of Dream.In.Code

Change in plans...

This is what I am going to do. I'm going to keep this blog going but only post short tutorials about C#. I'm going to create a new blog about the Role-Playing Game project in XNA. Once I've created the new blog I will post a link here to the blog.

Look for the new blog shortly and the first of my tutorials about C#.

Introduction to Tiling

Well, I'm not going to post the tutorial until the 13th. What I am going to post today is the basics of creating a map and you would draw the map.

For a simple tile map, the best thing you can do is make an array of integers to the index of like this:

int[,] map = new int[,]
{
    {0, 0, 0, 0, 0, 1, 0, 0, },
    {0, 0, 0, 0, 0, 1, 0, 0, },
    {1, 1, 1, 1, 1, 1, 1, 1, },
    {0, 0, 0, 0, 0, 1, 0, 0, },
    {0, 0, 0, 0, 0, 1, 0, 0, },
    {0, 0, 0, 0, 0, 1, 0, 0, },
};

You can think of the 0's representint the first tile that is say a grass tile, 1's represent the second tile that is say a road tile. , the 2's would represent another tile, and so on.

static int tileWidth = 32;
static int tileHeigh = 32;

It would be a good idea to create two variables to hold the height and width of the tiles you are going to use like this:

Before you can draw something you would have to load the Textures in the LoadContent method. I'm not going to go into that, this is just a quick introduction (because I still haven't found tiles I like). But I will assume that there is a list of tiles that was loaded in the LoadContent method. This is how the list was defined:

List<Texture2D> tileList = new List<Texture2D>();

So, how do you draw the map?

In XNA you will do that in the Draw method. You would do something like this:

int mapWidth = map.GetLength(1);
int mapHeight = map.GetLength(0);
int index;

spriteBatch.Begin();

for (int y = 0; y <>
{
    for (int x = 0; x <>
    {
        index = map[y, x];
        spriteBatch.Draw(tileList[index],
            new Rectangle(x * tileWidth,
                y * tileHeight,
                tileWidth,
                tileHeight),
            Color.White);
    }
}
spriteBatch.End();

Looking at the code you might be thing: He's got the x and y backwards! Truth is typically in math coordinates are writen (x, y) so are screen coordinates. For our tile engine to work we have to reverse them to (y, x).

The drawing code works this way. I get the size of the map that I will be drawing and define a variable to store the index of the texture in our list.

Then I call spriteBatch.Begin(). If you are going to draw Texture2Ds you have to put the
drawing code between a spriteBatch.Begin() and a spriteBatch.End().

I set up two for loops. I start at coordinate (0, 0). Then I go through the rows of the array and draw the tile using the spriteBatch.Draw method. There are many overloads to the Draw method. I just used the first one. The parameters are:

1. the texture to be drawn


2. the destination rectanlge on the screen


3. the tint color

The texture is easy. It is just the texture from the list indexed by the index from the tile map. The destination rectangle is what needs explaining. The destination rectangle is a rectangle whose x and y coordinate will go someting like this: (0, 0), (32, 0), (64, 0), (96, 0), ... for the first row and (0, 0), (0, 32), (0, 64), (0, 96), ... for the first column.

The second row would go like this (32, 0), (32, 32), (32, 64), (32, 96), ...

The second column would go like this (32, 0), (32, 32,), (32, 64), (32, 96)...

You will see better when I manage to get the tutorial for the tile engine working.

The tint color allows you to tint your textures. Typically you don't want any tint so you put in Color.White. That is the basics of how tile works. There are a few more concepts to be tied in. Such as preventing the map from scrolling off the screen, only drawing the portion of that map that is visible and scrolling the map in general.

What's up...

Well, I have been very busy the past few days. I'm trying to find some nice textures to use for the tile demonstration, so far I have not had very much luck. The tile program is done though and I am trying to write it up. I might download the Role-Playing Game starter kit from the XNA Creators Club and use some of those tiles. I don't think they can be distributed with the finished game though. I have found some nice ones for isometric tiling but I don't want to get into that.

Look for the tutorial maybe on the 11th or the 13th at the latest. I am not going to be doing anything on the 12th as it is Easter.

Introduction to XNA 3.0

XNA Game Studio 3.0 is a Framework offered by Microsoft for creating games with C#. With it you can create Windows games, XBOX 360 games and games for Zune. I don't have an XBOX 360 or a Zune so I really have no idea about those platforms.

For Windows games you must meet the minimum requirements for Visual C# 2008 Express Edition and you must have a graphics card that supports Pixel Shader 1.1 or better. Most modern ATI and nVidia graphics cards support Pixel Shader 1.1 or better. If you do not have a card that supports Pixel Shader 1.1 you really can not program in XNA.

In XNA you have the Content Pipeline. It is used to import a wide variety of content to your project. For the purposes of what I will be doing all you have to worry about is Texture2D, which will be used for tiling and sprites and sound files. Eventually there will be some XML files but I am going to make custom importers, processors and exporters to compile them into .XNB files. Otherwise the XML files could be edited by others playing your game and they can change the content of your game.

XNA has two methods that are called often. They are the Draw and Update methods. In the Update method you process thing like input, collisions, moving objects, etc. In the Draw method you draw your scene. The rate at which they are called can be changed programmatically.

Tomorrow, or the next day, I plan on posting a tutorial on how to do basic tiling. So look for that in the next do or so.

The next tutorial

I am hoping that the next tutorial will be ready Sunday. But until then I want to make a mini-post.

I find the documentation on how to check if a key has been pressed and released a little confusing. Here is a simple way to do it. You need to save the old state of the keyboard and compare it to the current state of the keyboard. I believe what they are checking is if the current state of the keyboard the key is down and the last state of the keyboard is up. I think that it works better if the current state of the keyboard is up and the last state of the keyboard is down.

So, create an XNA game. In the Game1.cs file add a variable at the top of the class to hold the old state of the keyboard and a variable to hold a color:

KeyboardState oldState;
Color bgColor = Color.White;

Now in the Update method add a call to a new method:

CheckKeyboard();

Now, write the CheckKeyboard method as follows:

private void CheckKeyboard()
{
  KeyboardState currentState = Keyboard.GetState();

  if (currentState.IsKeyUp(Keys.Space))
    {
      if (oldState.IsKeyDown(Keys.Space))
      {
        bgColor = new Color((byte)~bgColor.R,
          (byte)~bgColor.G,
          (byte)~bgColor.B);
      }
    }

    oldState = currentState;
}

Now just replace the Color.CornflowerBlue in the Clear call to bgColor in the Draw method. When you run the program the screen should switch between black and white when you press the Space key and let it go.

Give it a try and see how it works. I am not posting the project for this simple tutorial.

Managed DirectX Tutorial 6

I have finished today's tutorial. In this tutorial I show how to draw a triangle using Managed DirectX. It isn't exactly in 3D yet but I believe you have to start somewhere. There are two ways that you can do this tutorail. You can download the template and type in the additions to the template or you can download the project and just read the tutorial.

There is only one version of the tutorial because everything that I have added is new and deserves explaination. This is where you can find the tutorial.

Managed DirectX Tutorial 6

Direct3D Template

I have finished making the first draft of the template I mentioned yesterday. So instead of starting from scratch each time you will be able to use the template. After you have downloaded the template there is one thing that you have to do. You need to copy it to the following directory:

My Documents\Visual Studio 2005\Templates\Project Templates

This is where Visual Studio looks for templates by default. If you have changed the location where Visual Studio looks for template then you will need to put the .zip file in that directory. I will try and have the next tutorial up soon so come back later.

You can find the template here:

Direct3D Template

Sorry about the icon. I will never claim to be an artist. :)

Good news (for me any way)

I was unable to write my tutorial today because I got my laptop back from the shop. The hard drive had to be replaced so I had to spend the evening trying to restore everything. What is going to happen now is I will be starting another blog, one about using Visual C# Express 2008 and XNA Game Studio 3.0. I said in my first post that I was going to do XNA 2.0 but I think that it might be a good idea to use the most current software available. When I manage to get things up and running I will post a link here to the new blog. I will try to post a Starter Kit for the Managed DirectX tutorials that you will be able to download to create the projects that I will be writing so you can just add the new code. I will keep updating the Starter Kit to include the new features that will be added to the projects. I will still be posting the projects if you perfer to just download those and look at the code instead of typing it in.

My next tutorial

I'm sitting here trying to decide what to do next. I know so far these tutorials have not done a lot of drawing. So far all they have done is create blank screens. The question in my mind is what type of drawing should I do. There is 3D and 2D. Both have their merits. There are a lot of 3D games out on the market and I believe they are the most popular. Still 2D games also have their audience as well. I want to write a tutorial that will appeal to the broadest audience possible. What I am thinking is doing an alternating format. 3D one day and then 2D another. 2D is an important aspect that should be considered when making games. A lot of games require text to written to the screen, especially my favorite, role-playing games.

Both systems also have their difficulties. That is why I started out just setting up Direct3D in the first 5 tutorials. Now I will start writing tutorials that render scenes and try to build incrementally on them. Like I mentioned yesterday I will try and write two different tutorials. One for those who haven't done the previous tutorials and one that will start off where the last one had left off.

So stay tuned for the first 3D tutorial. It should be posted soon, maybe even today.

Managed DirectX Tutorial 5

Good news, I found the time to write the tutorial today. Today's tutorial shows how to make a pop-up window in your program using Managed DirectX. I have also written two versions of the tutorial. The first I call the Full Version. In it I describe everything that I am doing for those of you who have not gone through the other tutorials. In the short version I go over things more quickly and try to only explain the things that are different in this tutorial.

This is the full version: Tutorial 5 Full Version

And this is the short version: Tutorial 5 Short Version

And this is the link to the project: DirectX Tutorial 5

New format

Okay, I have been considering the format of these tutorials. I am finding that it is hard to read them. What I am going to do is post general information about the tutorials here so if you are interested you can click a link to go to the full tutorial. They will be posted on my website, hopefully in a format that is easier to read. I will also post a link to the project that you can download if all you want is the code. The projects that I will be posting will contain comments from now on to explain what is going on.

Today I am writing a tutorial about going full screen in DirectX. There are a few differences between windowed and full screen mode. You can't just set the Windowed property to false and expect your program to work in full screen mode. There is a little work that needs to be done before you can run in full screen. One important thing that you need to do is have a way to exit the program. This will be accomplished by using the KeyDown event handler. It will check to see if the Escape key has been pressed and then exit the program.

The code is finished and has been tested. I just have to write the tutorial. Check back a little later and I will post the link to the project when it has been uploaded to my website.

Managed DirectX Tutorial 4

I have been working on a new tutorial but I don't know when I will be able to post it. I'm hoping to post it later on today but it might not be ready. I might also start posting these tutorials on www.dreamincode.net. My member name there is SixOfEleven.

The tutorial that I'm working on now is drawing sprites using Direct3D. Direct3D itself does not have sprites. You need to also use Direct3DX.

Managed DirectX Template for C#

I've been working on the template that I talked about yesterday. It is coming along very well. I'm trying to make it so that the size of the window or screen can be set when the Direct3D device is created by just changing a few variables in the Program.cs file. Also, I tried to make it so that there are seperate methods for the logic and the rendering methods. So far the template is coming along quite nicely.

I'm going to write a tutorial about how to seperate the logic and rendering methods.

So, to start Visual C# and create a new project. Like you did in the previous tutorials you will have to add the references to Microsoft.DirectX and Microsoft.DirectX.Direct3D. If you missed the first two tutorials you do this by clicking the Project menu item then selecting Add reference item. When the window pops up select the .NET tab scroll down and click the Microsoft.DirectX entry and holding down the Crtl key click the Microsoft.DirectX.Direct3D entry.

Open the code view for the form and add these two using statements.

using Microsoft.DirectX;
using D3D = Microsoft.DirectX.Direct3D;

You might be wondering why I put the D3D = in front of the second using statement. The reason is simple. In managed DirectX Direct3D, DirectSound and DirectInput (which we are not using right now) every thing is a Device. By adding the D3D = you can easily qualify everything so there is an easy way to know what Device you want to use. You will see how this works in a moment.

Right now we are going to modify the Program.cs file. So open the code for that file. You want to change the Main method.

First delete the line:

Application.Run(new Form1());

You will be replacing this with different code. So go ahead and add the following code:

using (Form1 frm = new Form1())
{
    if (!frm.InitializeDirectX())
    {
        MessageBox.Show("Error creating DirectX.");
        return;
    }
    frm.Show();
    frm.Run();
}

What this code does is create a form and disposes of everything when it leaves the code block. First it tries to initialize DirectX. If that fails it reports an error and exits the program. Then we make sure that the form is visible and then call the Run method of Form1 that we will write shortly. Go back to the code view of Form1 and add the following a variable as follows:

private D3D.Device device = null;

Now we will write two methods. The InitializeDirectX and the Run method. They are both fairly simple.

public bool InitializeDirectX()
{
    D3D.PresentParameters pParam =
        new D3D.PresentParameters();

    pParam.Windowed = true;
    pParam.SwapEffect = D3D.SwapEffect.Discard;
    try
    {
        device = new D3D.Device(0, D3D.DeviceType.Hardware,
        D3D.CreateFlags.SoftwareVertexProcessing,
        pParam);
    }
    catch
    {
        return false;
    }
    return true;
}

public void Run()
{
    while (this.Created)
    {
        GameLogic();
        Render();
        Application.DoEvents();
    }
}

The first method should be familiar to you if you have followed the tutorials. The Run method might require a little explaining. First it is a simple loop that runs while the form is open. The this.Created flag is valid while the form is open. Next there are three method calls. GameLogic and Render are methods that we will write. The last tells the program to run the events for the form.

Right now the GameLogic method is just a stub that can be writen later. The Render method is where we will do the rendering. So create two methods as follows:

private void GameLogic()
{
    // TODO: add game logic here
}

private void Render()
{
    device.Clear(D3D.ClearFlags.Target, Color.Blue, 1f, 0);
    device.Present();
}

The Render method should be familiar to you, it is the same code that was used in the previous tutorials. The GameLogic will be written later when you actually start to write games.

So that is all for today. Later I will make the project available for download so check back a little later.

Newest Tutorial...

What I'm working on today is creating a template for using Managed DirectX in C#. So I probably won't be posting a tutorial today but who knows, I might get the time later on today. When I have the template finished I will make it available for download and will only post the changes that have been made for the new tutorials. I'm trying to make the template very robust so it can be changed easily to suit your needs. So check back soon and I will try to have it available for download.

Add projects for download

I have added the projects for download. You should be able to click these links to get them.

Managed DirectX Tutorial 1
Managed DirectX Tutorial 2

I have changed my mind about the next tutorial. If you are interested in going fullscreen and being able to press the Escape key to exit I will just put a link to the project on the blog. What I'm going to write about is the starts to making a game engine using Managed DirectX. So stay tuned and look for the next tutorial shortly.

Second managed DirectX tutorial

Today I'm going to show you how to create two Direct3D devices on the same form that work indendantly of each other. This is an easy way to develop a split screen game where you could play multiplayer games where each player has their own view.

To get started, create a new project in Visual C# and add the following references to your project Microsoft.DirectX and Microsoft.DirectX.Direct3D as you did in the last tutorial. Now with Form1 open in design view edit the properties of the size of the form to be: 610, 429. Next drag to panels from the toolbox onto the form. Technically you should give them meaningful names but this is a simple tutorial so you don't have to.

Change the location of panel1 to: 0, 0. Then change the size of panel1 to: 300, 400. Now change the location of panel2 to : 301, 0 and the size to 300, 400. That is all that needs to be done to set up the form for two Direct3D devices.

Like in the last tutorial two using statements have to be added to the code of Form1. They are:

using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

Now you need to add two device variables:

pulic Device device1 = null;
pulic Device device2 = null;

Switch back to the design view of Form1 and either double click the title bar of the form or open the properties window and click the Events button, scroll down to the Load event handler and double click that to add the Form1_Load event to the code. If you have the properties window open go ahead on scroll down to the Paint event and double click that now as well to add the Form1_Paint event handler.

Add the following code to the Form1_Load event handler:

InitializeDirectX();

if (device1 == null || device2 == null)
{
    MessageBox.Show("Error creating DirectX device.");
    Application.Exit();
}

After you have added the code to the Form1_Load event handler add this code to the Form1_Paint event handler.

device1.Clear(ClearFlags.Target, Color.Blue, 1.0f, 0);
device1.Present();
device2.Clear(ClearFlags.Target, Color.Red, 1.0f, 0);
device2.Present();

Now all you have to do is add the InitializeDirectX method. It is as follows:

private void InitializeDirectX()
{
    PresentParameters presentParams = new PresentParameters();

    presentParams.Windowed = true;
    presentParams.SwapEffect = SwapEffect.Discard;

    device1 = new Device(0, DeviceType.Hardware,
        panel1,
        CreateFlags.SoftwareVertexProcessing,
        presentParams);
    device2 = new Device(0, DeviceType.Hardware,
        panel2,
        CreateFlags.SoftwareVertexProcessing,
        presentParams);
}

If you build and run your program you should see two panels, one of them blue and the other red. One thing worth mentioning is that you do not have to use the same presentation paramaters when you create your devices so you can have different effects for both panels.

That is all the time that I have today. I will try and post another tutorial tomorrow but it is spring break for the kids here and we have company coming so I might not get around to it. If I can find the time I will try and put the projects for this tutorial on my website for download. Check back soon, hopefully I will have another tutorial ready. What I am planning is showing how to go full screen and be able to press the Escape key to exit the program.

Creating a DirectX Skeleton

Welcome back!

In this post I will show you how to set up a simple DirectX program using Visual C# Express 2005 using Managed DirectX. This post might be of interest of those of you who want to write games using C# but do not have a graphics card that supports Pixel Shader 1.1, which is required to write games with XNA.

You will need to install the DirectX SDK from microsoft. It can be found here:

http://msdn.microsoft.com/en-us/directx/aa937788.aspx

After you have it installed you are ready to begin.

The first thing you will need to do is start Visual C# and create a Windows Application.

Now you have to setup your program to use DirectX. To do this you have to enter two references. Click the Program menu item, then select the Add Reference entry.

You will choose the Microsoft.DirectX and Microsoft.DirectX.Direct3D enteries in the .NET tab.

Open the code view tab for Form1. You will want to add two using statements at the top of the program:

using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;


After adding the using statements you will need to add a variable for the Direct3D device.

public Device device = null;

Go back to the Design view of Form1 then double click on the form (or you could click the events button on the properties window and double click the Load entry.) This will bring up the event handler for the Form Load event. Add the following code:

    InitializeDirectX();

    if (device == null)
    {
        MessageBox.Show("Failed to initiralize DirectX");
        Application.Exit();
    }

Now we will write the InitializeDirectX method.

private void InitializeDirectX()
{
    PresentParameters presParams = new PresentParameters();
    presParams.Windowed = true;
    presParams.SwapEffect = SwapEffect.Discard;

    device = new Device(0, DeviceType.Hardware, this,
            CreateFlags.SoftwareVertexProcessing,
            presParams);
}

The first thing this method does is create an instance of the presentation parameters for our device. In this tutorial I will not explain them too much as this is just to get your feet wet. The two fields that we are changing are Windows, which tells us if we want to use windowed or fullscreen for this device. The second, SwapEffect, tells the device how we want to deal with swapping from the backbuffer to the device. In this case we simply want to discard it. There is one more thing that we have to do to get the program ready to display. We need to add code to the Paint event for the form.

So, switch to the design view of your form and in the properties windon click the events button. Then scroll down to the Paint event and double click it. This will bring up the event handler for the Paint event. For this sample all we are going to do is clear the window then draw the window.
Add the following code to the Paint event:

    device.Clear(ClearFlags.Target, Color.Blue, 1.0f, 0);
    device.Present();

All that we are doing here is clearing the buffer then presenting the scene to our devie. The parameters for the Clear method are: ClearFlags - describes what we want to clear, Color - a System.Drawing.Color, the color we want to clear the buffer to, zBuffer - I will go into this later when we start doing 3D work, stencil - this deals with stencil buffers, for now just set this to 0.

That is all you need to setup a device using Managed DirectX
I will try and make another post in the next day or so. Come back an look form more!