Game programming from scratch

In programming there are several different... I guess I could call them branches, each requiring very different skills, to name a few we have

• Operating System's development
• Device programming
• Device drivers
• Anti-virus
• Virus writing
• Large Frameworks (I'm talking about .NET for example)
• Game programming

Event just in Windows you could talk about

• Native win32
• Managed
• windows services
• web services
• web programming
• etc...

Game programming is one of those branches that requires a lot more knowledge on quite a few different topics than (and usually in addition to) regular traditional programming.

Game programming is something that I have always been interested in, the most I've done however, are a couple text based games and a domino game that can be played over a LAN; as part of my interests I have studied OpenGL and DirectX, I even wrote a few beginner articles on Delphi and OpenGL.

I have read quite a bit about game programming in general, enough to know that your first game should be something simple, most people trying game programming for the first time attempt to create something big like a 3D first person shooter, most people however, fail.

The guys who have been there and know game programming recommend you create something like a Tetris for your first game, even though this is a really simple game, it's got all the elements of any game

• input
• logic
• animation
• levels
• a game loop (every game has a game loop)

Other good choices for your first game could be an steroids, bricks, pac-man. If you need more ideas you could visit sites like miniclip, they have hundreds of flash games, you can even chose to write a simpler version of a game you chose, the whole point is that you should finish it, and once you finish it, maybe you extend it, but you would have already finished v1.0 of your first game and that is really important.

These days starting a game "from scratch" is really far from what it used to be just a few years ago, where you had to create everything, maybe even your own format and format loader, and every single pixel that was drawn you had to write code for that, years have gone and now we have standard formats for models, sounds, graphics, etc. and most importantly we have plenty of frameworks to build your game on top of them.

One of the latest and greatest frameworks to create games is XNA; you can think of XNA for game programming pretty much like Visual Studio for programming in C#, it allows you to focus on the actual game (theme, logic, etc), giving you all the functions ready to be used to do most of the drawing stuff, one of the cool things about XNA is that it will allow you to run your own games in your XBox 360, it doesn't get much better than that

A couple of friends and I have decided to start writing games just for fun, we will probably start with a simple pac-man, although we'll plan on making it extensible, we'll start with something really simple.

A rough idea of what we're shooting for if we go for the pac-man would be:

• Single world
• Single level
• one type of ghost
• we'll most likely create our own graphics in Paint and create our own sounds.

points of extensibility could be

• plug-in model to create new ghosts
• plug-in model to create new worlds and levels

as simple as that is, it allows you to extend as much as you can, however, we have to get there first.

I will blog about all my experiences (and source code) creating this first game, I'm really hoping not to fail as many have before. Just as many guys before me, I hope to, if not help, at least inspire other people to start in the wonderful art of game programming

If you want to join me, you could start by downloading XNA and Visual Studio 2005 Express Edition, you also need to download The Wizard, which is a simple animation that will teach you most of the basics of what you need to create your first game and will help you get familiar with XNA.

Until next time

google reader finally has a decent user interface

I have been using google reader for a couple months now, but to be honest it had a horrible user interface, until just now, it finally groups the feeds by category in folders and shows you counts of unread items... just like a normal RSS reader

this is probably all over the news now, but I just logged in to check my blogs and saw the new interface, it wasn't there this morning... anyway, check it out

Simple Generic Factory

Last time I presented you with simple factory pattern using dictionaries of methods and talked about Steven's (much more elegant and generic) implementation. I kept playing with Steven's code, whilst the dynamic code generation is pretty cool I kept thinking there was an easier way to accomplish the same thing; I finally came up with a much shorter version, here it is:

public static class SimpleStaticGenericFactory<TKey, TBaseType> where TBaseType : class {
    public delegate TBaseType BaseTypeInvoker();
    private static Dictionary<TKey, BaseTypeInvoker> methods = 
        new Dictionary<TKey, BaseTypeInvoker>();
    public static void Add(TKey key, BaseTypeInvoker instantiatorMethod) {
        if (!methods.ContainsKey(key))
            methods.Add(key, instantiatorMethod);
    }
    public static void CreateInstance(TKey key) {
        if (methods.ContainsKey(key))
            methods[key]();
        else //what would you like to do in this case?
            throw new ArgumentException(string.Format("{0} not found", key));
    }
}

that's it!, or if you prefer the non-static version:

public class SimpleGenericFactory<TKey, TBaseType> where TBaseType : class {
    public delegate TBaseType BaseTypeInvoker();
    private Dictionary<TKey, BaseTypeInvoker> methods =
        new Dictionary<TKey, BaseTypeInvoker>();
    public void Add(TKey key, BaseTypeInvoker instantiatorMethod) {
        if (!methods.ContainsKey(key))
            methods.Add(key, instantiatorMethod);
    }
    public void CreateInstance(TKey key) {
        if (methods.ContainsKey(key))
            methods[key]();
        else //what would you like to do in this case?
            throw new ArgumentException(string.Format("{0} not found", key));
    }
}

We *don't really need* the CreateInstance method there, we could call the method directly if the dictionary was public, but it wouldn't be good to give them access to the dictionary. Using the reports from our last example, we could use it like:

SimpleStaticGenericFactory<string, BaseReport>.Add("report1", delegate() { return new Report1(); });
SimpleStaticGenericFactory<string, BaseReport>.Add("report2", delegate() { return new Report2(); });
SimpleStaticGenericFactory<string, BaseReport>.CreateInstance("report1");

or using the non-static version:

SimpleGenericFactory<string, BaseReport> reports1 = 
    new SimpleGenericFactory<string, BaseReport>();
reports1.Add("report1", delegate() { return new Report1(); });
reports1.Add("report2", delegate() { return new Report2(); });
reports1.CreateInstance("report1");

nice and simple, I'll put an example together for a plug-in model using this factory

Simple factory pattern using Dictionaries of methods

I have been talking about arrays of methods, dictionaries of methods, how both techniques are very similar in implementation, when you can use either one, and a practical implementation of the simple factory pattern using arrays of methods. Today I'll show you the implementation of the simple factory pattern using dictionaries of methods and then we'll move into more interesting things, Steven posted an implementation of the same pattern that leaves my implementation in the dust, I'm still posting my code here as another example of how you can use dictionaries of methods. 

using ReportCreatorDictionary = Dictionary<string, ReportCreatorDelegate>;
//this is our base product
abstract class BaseReport {
    public BaseReport() {
        Console.WriteLine("Base Report Created");
    }
    public abstract void Execute();
}//product 1
class Report1 : BaseReport {
    public Report1():base() {
        Console.WriteLine("Report1 created");
    }
    public override void Execute() {
        Console.WriteLine("Report1");
    }
}//product 2
class Report2 : BaseReport {
    public Report2():base() {
        Console.WriteLine("Report2 created");
    }
    public override void Execute() {
        Console.WriteLine("Report2");
    }
}

delegate BaseReport ReportCreatorDelegate();
//this is the actual factory
class ReportGenerator {

    static BaseReport CreateReport1() {
        return new Report1();
    }

    static BaseReport CreateReport2() {
        return new Report2();
    }

    static ReportCreatorDictionary reports;

    static ReportGenerator() {
        reports = new ReportCreatorDictionary();
        reports.Add("Report1", new ReportCreatorDelegate(CreateReport1));
        reports.Add("Report2", new ReportCreatorDelegate(CreateReport2));
    }

    public static BaseReport Execute(string reportType) {
        return reports[reportType]();
    }
}

and the way to use it:

BaseReport report1 = ReportGenerator.Execute("Report1");
report1.Execute();

BaseReport report2 = ReportGenerator.Execute("Report2");
report2.Execute();

of course the choice of the report to be executed can come from anywhere (drop down list, link on a web page, configuration, etc)

The problem with this implementation, as Steven points out, is that you have to change the factory every time you add a new product to the factory and is not flexible enough to create (for example) a plug-in model, because all the types are required to be known at compile time; and if you need a factory for another product you have write a new factory (duh!, you might think). Steve's implementation is a Generic factory that can be re-used with any other types (products); no need to write the factory, you just add the products to it and is ready to be used, go check it out, is definitely worth reading.

Steve's code has given me another idea, I'll see if it actually works the way I have pictured it and then blog about it

for now here's the code for the dictionaries of methods and this example of the factory; as always, play with it, learn from it, improve it

IE "Blog this" integrates with Live Writer

a few days ago I was reading on Geoff's blog that he became a Live Writer Junky and I commented that I just missed the "blog this" and "send to web snippets" features from Flock; well, Geoff wrote an extension for IE that adds this functionality and allows you to blog in Live Writer kinda the way Flock does it, but of course you get all the niceties (is this a word?) of Live Writer

that also led me to learn something new, I didn't know it was so easy to create an extension for IE, just using javascript and some registry keys, check it out

Basic good practices

I've been kinda busy lately doing a lot of refactoring, I hope to be back to post about C# interesting things like generics and patterns soon

meanwhile, I've been catching up reading my blogs, I got to this post from Jeremy Miller, "The Will to be good", there are a few points that I have always taken to heart:

1. Don't tolerate bad code. 
2. Don't write code on top of bad code.
3. Fix a broken build
4. The "design hat" never comes off.
5. Does quality even matter?. Absolutely

For me these things are more basic than even testing, if you follow these simple guidelines your tests will run smoothly

I don't tolerate bad code and/or developers who write sloppy code, I don't even tolerate to have warnings in my code

You will always find people in some teams who are not very good at these basic things (and I'm not talking about my current team, in case they are reading this), and you have to learn how to deal with these people, if you are the team lead that's part of your job, you have to show them better techniques, even though I know is hard, specially if you are younger than them; if you are not the team lead it gets even harder, but all you can do is be an example, if you follow those practices you will be a better developer than one that doesn't, and people will see that and start listening to you at some point.

Managers may get scared when they hear you are refactoring like mad, but that shouldn't stop you from doing so (you might even have to do it after work hours), after all you are just making life easier for you and your team

Wasabi on Wails

People rewriting their stuff in this new cool framework, what are you waiting for?

JJJ

smart-er Rootkits in Codecs

I'm afraid this is going to bite a LOT of people

You’re surfing the web, and you find a video that you really want to watch, (no, not one of “those” videos… well, not necessarily anyway), but it says you have to install a codec. Codec stands for compressor/ decompressor and is used to make otherwise huge video files into a more manageable size. You install the codec, and maybe you see the video, and maybe you don’t, but guess what? You’ve been rootkitted! Now, on one level, that’s just the classic bait and switch/ trojan horse scenario, but the _details_ are quite interesting.

be careful out there

photoshop amusement

truly amazing what some people can do with Photoshop (click on the picture to see a bunch more)

Incremental search in Internet Explorer "a la Firefox"

In case you haven't seen this yet (and if you use Internet Explorer for whatever reason), you can now have the (very requested) feature of finding text as you type in IE, almost like in Firefox

Find as you type

Dictionaries of methods in C#

This article is a follow up of my previous article arrays of methods in C#, as noted by some of the commenters, it is possible to implement this technique using dictionaries, Steven even (Steven even... kinda funny... anyway, where was I? oh ok) posted a comment with the full implementation of my code using dictionaries, I just wanted to hightlight some of the differences and perhaps give you a hint on when to use either one (although it should be obvious, but I've learnt that there is no such thing as obvious)

Since the dictionaries implement a <Key, Value> way of storing stuff, you can store an int or a string, or any other type as the key as long as you don't have duplicated entries, and on the value you can store the pointer to the method you want to execute, when using arrays you are limited to use types that can be converted to integers for the index, with dictionaries you could use other types as the index.

let's see the last example and how it changes, the changes -as you will see- are pretty minimal to switch between the two

- The delegate declaration doesn't change

- now instead of an array, we have a dictionary, it looks something like this:

Dictionary<int, AddStringDelegate> addStringMethods;

- The methods declaration stay the same

- Adding the methods to our dictionary is just a little bit different:

addStringMethods = new Dictionary<int, AddStringDelegate>(4);
addStringMethods.Add((int)StringType.Type1, new AddStringDelegate(AddStringType1));
addStringMethods.Add((int)StringType.Type2, new AddStringDelegate(AddStringType2));
addStringMethods.Add((int)StringType.Type3, new AddStringDelegate(AddStringType3));
addStringMethods.Add((int)StringType.Type4, new AddStringDelegate(AddStringType4));

- The implementation to use the methods remains exactly the same

public void AddString(string someValue, StringType stringType) {
  addStringMethods[(int)stringType](someValue);
}

We're done! so we just had to change a couple places and we are now using dictionaries of methods instead of arrays.

So when do I use dictionaries over arrays? basically, when you need it, arrays are a lot more simple and lightweight, dictionaries add weight but give you a lot more flexibility, for example if you want to use a string as the index to access your method, then the dictionary is the way to go; dictionaries also allow you to add/remove items from it, I don't know that it would be a good idea to apply that in this case, but you can do it. If you can get an integer index I would use the array instead, you don't really need the dictionary in that case.

If no one (out of my 3 readers J) beats me to it, I'll run some tests using both approaches and see if there is any relevant difference in speed and I'll post the results here. If you do the tests, and you blog about it, and I find out, I'll put a link here just as a follow up to this

Here's the full code, play with it, break it, expand it, make it better

class FileGeneratorBase {

    Dictionary<int, AddStringDelegate> addStringMethods;

    public FileGeneratorBase() {
        addStringMethods = new Dictionary<int, AddStringDelegate>(4);
        addStringMethods.Add((int)StringType.Type1, new AddStringDelegate(AddStringType1));
        addStringMethods.Add((int)StringType.Type2, new AddStringDelegate(AddStringType2));
        addStringMethods.Add((int)StringType.Type3, new AddStringDelegate(AddStringType3));
        addStringMethods.Add((int)StringType.Type4, new AddStringDelegate(AddStringType4));
    }

    public void AddString(string someValue, StringType stringType) {
        addStringMethods[(int)stringType](someValue);
    }
    void AddStringType1(string someValue) {
        OutputText(string.Format("String Type 1: {0}", someValue));
    }
    void AddStringType2(string someValue) {
        OutputText(string.Format("String Type 2: {0}", someValue));
    }
    void AddStringType3(string someValue) {
        OutputText(string.Format("String Type 3: {0}", someValue));
    }
    void AddStringType4(string someValue) {
        OutputText(string.Format("String Type 4: {0}", someValue));
    }
    void OutputText(string someValue) {
        Console.WriteLine(someValue);
    }
}

class Program {
    static void Main(string[] args) {
        //*** Arrays of methods demo
        FileGeneratorBase fg = new FileGeneratorBase();
        fg.AddString("some value", StringType.Type1);
        fg.AddString("some other value", StringType.Type2);
        fg.AddString("one last value", StringType.Type3);
        fg.AddString("testing out of bounds", StringType.Type4);
        Console.ReadLine();
    }
}

on my next article I'll show you the implementation of this technique applied to the simple factory pattern just to close the loop.

Simple factory pattern made simpler

A Simple Factory pattern returns an instance of one of several possible classes depending on the data provided to it.

Last week I talked about a technique that allows you to reduce (and effectively reuse) code when you have a pattern of 2..n values, where for each value you want to execute a different method with the same signature

if (someValue == SomeEnum.Type1)
Method1("value 1");
else if (someValue == SomeEnum.Type2)
Method2("value 2");
else if (someValue == SomeEnum.Type2)
Method3("value 3");

while the method is valuable by itself, there is a pattern where it fits perfectly, this is the simple factory method; let's start with a reports example.

Suppose we have a Base Report class, and two implementations of it:

abstract class BaseReport {
  public BaseReport() {
      Console.WriteLine("Base Report Created");
  }
  public abstract void Execute();
}
class Report1 : BaseReport {
  public Report1():base() {
      Console.WriteLine("Report1 created");
  }
  public override void Execute() {
      Console.WriteLine("Report1");
  }
}
class Report2 : BaseReport {
  public Report2():base() {
      Console.WriteLine("Report2 created");
  }
  public override void Execute() {
      Console.WriteLine("Report2");
  }
}

enum ReportType {
  Report1,
  Report2
}

To use the arrays of methods, we have to declare our delegate to instantiate the reports:

delegate BaseReport ReportCreatorDelegate();

Then we have our factory class that contains:

• An array of methods


• a method to instantiate each report


• The method to execute the requested report, depending on the parameters

class ReportGenerator {
  static BaseReport CreateReport1() {
      return new Report1();
  }
  static BaseReport CreateReport2() {
      return new Report2();
  }
  static ReportCreatorDelegate[] reports;
  static ReportGenerator() {
      reports = new ReportCreatorDelegate[2];
      reports[0] = new ReportCreatorDelegate(CreateReport1);
      reports[1] = new ReportCreatorDelegate(CreateReport2);
  }
  public static BaseReport Execute(ReportType reportType) {
      return reports[(int)reportType]();
  }
}

Then here's how we use this code:

BaseReport report1 = ReportGenerator.Execute(ReportType.Report1);
report1.Execute();

BaseReport report2 = ReportGenerator.Execute(ReportType.Report2);
report2.Execute();
Console.ReadLine();

Update: Pablo commented "the fact that calling the factory with the type you want to create is kinda the same as creating it yourself", it is true, I could've just created an instance directly my self there, but this was just a bad example from my part, that value could come from a drop down select list, from a configuration file, etc, I just did a bad job showing you how you could use the code.

This particular example is very light weight and works great to implement this simple pattern, but it has the limitation that it works only for values that can be converted to integerAyende and Steven pointed out that the same technique can be implemented using Dictionaries, this would allow us to have other types as the index of our collection of methodsOn my next posts I'll show you this technique, using Dictionaries of methods

You can find the full source code for this and my previous example here

How to install multiple personalities of Turbo Explorer

Andy has created a program that allows you to install multiple personalities of the Turbo Explorer products (since by default you can only install one)

The steps, according to Andy are really simple:

How to install
==============
1. Install the first Turbo Explorer personality with the installer
that is included in the Turbo Explorer download.
2. Extract the next Turbo Explorer personality installer to a directory
of you choice.
3. Start the TurboMerger.exe and select the directory where you have
extracted the next Turbo Explorer personality installer. Press the
"Install" button. In the InstallShield installer do not change the
directories. Doing this will destroy the Turbo Explorer installation.
4. Proceed with step 2. until you have installed all personalities you
want.

if you are one of the people who downloaded these products, this is definitely a must have

where Delphi stands right now

Daniel Wichnewski just posted the number of downloads for the turbo explorer products, a few thousand downloads, these are the most significant numbers:

turbocpp.exe: 464
turbocpp_de.exe: 348

turbocsharp.exe: 232
turbocsharp_de.exe: 226

turbodelphi.exe: 766
turbodelphi_de.exe: 851

turbodelphi4net.exe: 200
turbodelphi4net_de.exe: 266

Delphi for .NET doesn't seem to be very popular

XML Notepad

going through my blogs I found this little tool

XML Notepad 2006 provides a simple intuitive user interface for browsing and editing XML documents.

definitely one more to have in the toolbox

Finding great developers

Joel talks about his experiences hiring developers and how difficult it is to get the great ones, his main point is that the great developers are already taken and that most of the resumes you get are from the pretty bad developers 

The great software developers, indeed, the best people in every field, are quite simply never on the market.

The average great software developer will apply for, total, maybe, four jobs in their entire career.

I guess I'm on a good path, I'm still on my first job J

I've had many discussions with co-workers about this same topic, while I pretty much agree with everything Joel says on this post, there's some people who think that is not that hard to get good developers

I'm of the idea that from a generation of (so-called) computer scientists you get one or two good developers (the great ones are a lot more rare than that)

Joel then goes on describing how you could get some of those great developers:

Go to the mountain

Internships

Build your own community*

That pretty much leaves out medium and small companies, there's no way they could afford to do things like that

He closes the article by listing some problems you might face if you use employee referrals

Unfortunately for me I haven't personally met anyone that I consider a great developer, I wish I had because I would've learnt so much more and faster; I have met very few that I consider good developers, but I guess is all up to your own standards, it's about how passionate you are about developing, it's about how good you are

Ayende pictures developing as an art, that describes it fairly well for me, I believe a talent is required, and as such, you are born with it, sure you can learn it, but you won't be anywhere near as good as someone who has the talent

This blog post doesn't make justice to Joel's article, Joel has been on the business for quite a while, he does know a thing or two about developers J, go check his article

The Turbos are back

Not the latest and greatest news, I'm just catching up with my blogs; the guys at "DevCo" have been working really hard and came out with free versions of the IDEs for Delphi, C++ and C#

What does it have for you? If you are using VS for .NET 1.x, not much, if you are using .NET 2.0 there's (almost) nothing here for you, but if you still need Win32 applications, these are by far the best IDEs to create native win32 applications

 

Please Note! Only one Turbo Explorer edition can be installed per machine, so be sure to download and install the one that's best for you!

It's free and is the best, you can't go wrong with that

The download page is here