Porting HoverRace over to VS2019 was quite difficult. Porting Netpanzer over has been even harder. Compiling on Linux is really easy, but I’d really like to maintain a Windows build. One if the the tricky things about C++ is that there are so many different pre-build tools used to script the compilation process.

It took a bit of work, but I got the HoverRace C++ solution compiling in VS 2019. The solution had previously last been compiled in VS2010 Express, so there was quite a bit of deprecation and bug fixing to deal with. Luabind had a bug that made it break with more recent Boost C++ Libraries and only the recent Boost Binaries work with VS2019. The solution was compiling a fork of Luabind with a fix applied and recompiling WGOIS and OpenAL 32 in VS2019 and loading them into the Solution.

I checked it all into Github and typed up some documentation explaining how to compile, so hopefully HoverRace will continue to exist and maybe even attract new developers.

The github for this project is at https://github.com/johnsie/HoverNet

Got a few minor fixes to to do and then the name of the game will be sockets programming in C++

Delegates are used in C# if for some reason you want to pass methods as parameters.

For example:

You have the number 10 and you want to print it out in several different formats. You might have several different methods to do this:

• A method to print it as a whole number
• A method to print it as monetary currency with a pound, euro or dollar sign.
• A method to print it as a decimal

Fine… The thing that those those methods all have in common is that they take in the integer and do something with it. In this case the integer we pass will be 10, but by design it would probably be better if the methods can accept any integer eg. public void PrintAsMoney(int){}

We could create a delegate called PrintValue

public delegate void PrintValue(int value);

And that delegate can later be used in a method to represent the three methods

PrintValue printDelegate=PrintAsInt;
printDelegate+=PrintAsMoney;
printDelegate+=PrintAsDecimal;

We’ve now set which methods should be used when printDelegate is invoked. We already know that all those methods are compatible with our delegate because they can all accept an int.

So… let’s invoke the delegate

printDelegate(10);

Our program knows which methods to use and to pass the number 10 to, because we just specified that when we set the methods for printDelegate. So all in one clean swoop it passes the number 10 to each of those methods that were subscribed to the delegate and the required data is printed. This is a multicast delegate because it uses more than one method. A standard delegate will only pass one method but works pretty much the same way.

Today someone  asked me what the difference between a class and a static class was. Of course my mind went blank and I got to squirm for a bit. I think it’s basic software engineering that any developer should know and it was a bit embarrassing. So as soon as I got home I did some Googling, watched some videos. It’s nice being single and having time to do that kind of stuff. Here’s what I’ve come up with:

A static class is one which you don’t need to make an instance of but can contain a collection of useful functions.

For example x = Math.Sqrt(144): uses the Math class but of course you don’t need to create an instance of the Math class to do that. If you try to create an instance of the Math class you will get an error message… Because it’s static 😉

A method that belongs to a static class is therefore automatically a static method.

You identify  both by using the keyword ‘static’ to make it easier for other developers and the compiler to know what’s going on.

Eg: static class UsefulTool

public static void HelloWorld

This is useful for tools/methods that you may want to re-use in your projects. I’ve actually been using these sort of collections of functions for years, as would most developers who don’t like repeating code necessarily.

A static variable is one which is about the class, not the instance of the object. So, for example you could have a counter within your class that is incremented each time a new instance of the class is created. At any point you can get the value of the static variable without refering to the instance of the object:

x= Car.count;

The code above would display the number of instances of the Car object that we’ve created (If the static int count gets incremented each time the constructor is loaded. Ie every time there is a new instantiation of an object )

A non static class that can instantiated as an object can also have static methods. For example the Car class could have a static method called GetCount(); which returns the value of static int count.