Unfortunately, that’s not always the case. Even if the software is 100% perfect, there are still things that can cause us problems. Disk drives are physical machines, and as with anything physical they wear out over time. Eventually, they break. And when that happens, you may find yourself in the same situation I was in yesterday: a broken Subversion repository

I did an svnadmin verify and it would return errors all over the place (in a different place each time, too). Eventually, I had to concede that the repository was un-recoverable.

Luckily for me, I do weekly backups and my backup from last week was still usable. My backup strategy is actually very simple: hot-backup.py every sunday night. Technically, I probably don’t have to use hot-backup.py, since it’s unlikely that I’m going to be doing anything at 4am on a Sunday morning, but you never know

So I bought a new hard drive and kicked off the restore process. I don’t have a huge repository (~900 revisions [and counting!] and about 900MB.) - mostly the size comes from the fact that I’ve got copies of a few open source projects in there… I don’t know why; I should probably tidy up my repository one of these days…

Anyway, the restore process is really simple: just bunzip the file that hot-backup.py created last Sunday. It took a few minutes (a bit longer actually, cause I took the opportunity to upgrade to Subversion 1.6.11 while I was at it).

The most annoying thing was that after it was all complete, my repository was complete only up until last Sunday: I had to take my current working directory and manually apply all the changes that I had made since then to get it back to what it was. Isn’t there a corollary to Murphey’s Law that states that when the worst thing that could happen happens, it happens at the worst possible time? In my case, it was because my drive failed on a Sunday: just hours before the next backup would’ve occurred and I had a full 7 days worth of changes to manually reapply.

So it’s always a good thing when a hardware failure shows that all your obsessive backing up is actually worthwhile, but even with the best plans in place, there’s always a lesson to learn. In my case, I’ve decided to augment my weekly backups with some daily incremental backups. I’ve borrowed this script and set it up so that it backs up incrementally each night as well.

I think the next step would be to do some off-site backups. I’ve just got my backups happening to a different drive in the same computer (I was lucky, I guess, that only one drive failed). I really need to get my backups saved somewhere a little more isolated. But maybe I’ll wait until the next failure precipitates it…

South Australian Attorney General, Michael Atkinson has quit the front bench, and hence his post as South Australia’s Attorney General.

At current count, Gamers 4 Croydon has “only” received 3.7% of the vote in the seat of Croydon, and while that’s a lot more than the “less than 1 percent” predicted by Mr. Atkinson, it’s still pretty paltry.

They’ve also only received 0.8% of the vote for the Legislative Council. Now, I know very little of how this stuff works, but I’m pretty sure that’s well short of what is required to win a seat. Which is a shame, because it’d have been nice to have at least one person from that party representing gamers in South Australia. But maybe preferences will come their way? Of course, I’ve got no hope of deciphering how the preferences flow…

But never-the-less, Mr Atkinson’s resignation is a big step forward and hopefully Australia will (finally) be able to move into the 21^st centry and introduce an R18+ category after the next meeting of the Attorney Generals (slated for April). We’ll see, I guess. If the outcome is good, it seems we can be pretty confident that it actually was Mr Atkinson who was vetoing the change, dispite the fact that he’s said he’s not the only one opposed.

It’s a long video, but some of the stuff there really blows me away (I especially like right at the end where the zerg swarm over the base, destroying it in seconds)

So how do they do it? Obviously I don’t know, but I can guess.

The feature that makes it look like it does is the flocking behaviour. Now flocking is a fairly well-studied topic, and while Starcraft 2’s implement has some nice features, I don’t think it’s totally revolutionary. The main feature that I like about their flocking is the way that units in a big group like will “stream out” towards the goal in a long line, rather than trying to all stay in formation. Depending on the style of game, you might want them to stay in formation, but for what is basically a swarm of insects, the behaviour in SC2 looks really nice.

The main problem is how do you define the group so that flocking works, but not so that units get stuck. For example, imagine a situation like the one in the diagram below:

If you imagine you select both the red and blue units and click where the green “X” is. You would expect the red units to flock together and the blue units to flock together, but obviously, they would follow different paths.

Now, I don’t know how Starcraft does it, but to me this is a situation where a polygonal navmesh would shine. Basically, you define all units that are on the same polygon in the mesh as being in a single “flock” (and perhaps some additional logic to account for adjacent polygons) and then find a single path for the whole flock. Then the units would use a flocking/path-following algorithm (e.g. something like this) to make it look “natural".

Obviously, the path-finding in War Worlds is extremely basic compared to all of this (I don’t even use navmeshes yet!) but one day…

(Special thanks to this thread on gamedev.net for some of my ideas)

Just yesterday, we hear that our favourite Attorney-General, South Australian AG Michael Atkinson had a law passed saying that nobody would be “allowed” to post comments on South Australian websites without giving their full name and address, and that the first name and postcode needed to be published along with the comment.

From some of his comments, you really get the impression that he’s starting to lose his grip on reality:

“The AdelaideNow website is not just a sewer of criminal defamation, it is a sewer of identity theft and fraud.”

“You will publish false stories about me, invent things about me to punish me.”

So, of course there was an internet backlash. Now, I’ve only lived in this world for some 30 years, so I don’t have the “experience” of people like Mr. Atkinson, but let’s be honest here… if you didn’t see this coming, you’d have to have your head up your arse.

Then today, we hear that the law will be retroactively repealled (after the election). But still the bizarre comments from Atkinson continue:

“From the feedback we’ve received… the blogging generation believes that the law supported by all MPs and all political parties is unduly restrictive”

“I miscalculated the strength of feeling among teenagers and people in their 20s who have grown up with the internet and blogging and I underestimated their desire to have as a right the ability to make political commentary in the election period anonymously or under an assumed name.”

That first one, he’s basically saying “all us politicians are so out-of-touch that we had no idea that this would even register as a blip on the radar!” And as if it’s only “teenagers and people in their 20s” - who are all criminals anyway, right Mr. Atkinson? - as if they’re the only ones who care about being censored…

There is some evidence that “all MPs” who supported the bill were misled (presumably by Atkinson) into believeing that the laws were not as broad-ranging as they actually were (though you’ve got to wonder if anybody actually reads what they’re voting for?). Says the shadow attorney-general Vickie Chapman:

“He clearly wanted to use this legislation to hunt down any of those who criticised him or the Government and that was made absolutely clear yesterday by his statements and behaviour”

Which seems very much inline with some of the other stuff that Atkinson has been doing over the last few months

This whole thing is really wierd, in my opinion. Atkinson seems to have this bizzare persecution complex… anyway, it’ll be interesting to see what happens in March.

I won’t go into too much detail on how connections and such are managed, since a lot of that stuff is handled pretty well by ENet already. What ENet doesn’t handle, though, is how you structure your packets - from ENet’s point of view, you just get an array of bytes. But that’s not much use to us, since we think in terms of objects and fields. So the question is, how do we map between our objects and a simple byte array and back again?

When I started doing this stuff, I looked into Boost.Serialization, but I found it to be rather too much for the relatively simple requirements that I had. I decided that I could implement it myself in a short enough time and have full control over the serialised format.

The first part of solution comes from the packet_buffer class which works much like a SC++L stream (though much simplified) and lets us build up the binary data in a fairly easy and intuitive way. A basic outline of it’s implementation is below (I’ve omitted the implementation of the more obvious methods):

This provides the basic implementation of the “buffer”. As you can see, it’s a pretty basic wrapper around std::stringstream (though we could’ve used std::vector<uint8_t> or something as well). The slightly more interesting aspect is the following helpers:

So as you can see, these functions are what actually make it easy to serialise things. Want to serialise a string? Just use operator << to stream it in. An example of one of my packet classes is below, to show you the basic usage of my class:

As you can see, when you join a new game, the server sends to you the current name of the map (a string), the session identifiers for all the other connected players (integers) and the “colour” of yourself and the server (this is used to differentiate between players in the game: red vs. blue, etc).

The final difficulty comes when you receive a “bunch of bytes” from your peer. How do you know which class to deserialize? This is the only place where a bit of macro magic happens (and that’s really just to save a bit of typing). First of all, the header file:

And the corresponding .cpp file:

So at the top of the .cpp for the packet, we just call the PACKET_REGISTER(packet_type) macro and it’ll register itself with the system. This is what the identifier member of the packet class is for: it’s used by the PACKET_REGISTER macro to assign an integer to that packet type which we put into the packet_buffer when sending it to the other side.

For the time being, I’m just manually giving each packet type a unique identifier by hand. It’s not that much trouble (and there’s not a whole lot of packet types to do anyway). I’ve also got some error checking code in my packet_registrar::packet_registrar method so that if two classes have the same identifier, it logs the error so I can fix it.

And so, that’s basically it. The system is very simple, doesn’t take much to maintain and it will allow me (in the future) to handle some more advanced scenarios with relative ease (for example, I could use a variable-length encoding for integers to save space, I could implement compression, or I could add packet coalescing).

Next time, I’ll hopefully have some more screenshots or videos to show. I’m in the process of implementing some basic pathfinding, which has been fun and gives the units some much more “intelligent” (looking) behaviour…

I’ve been working a little on the AI which, as I blogged about before, is being done in Lua.

Now, there’s two main functions in the War Worlds AI which make up the bulk of the API. The first is the one I blogged about before, self:find_units. The other one is self:issue_order (note: “self” in these function calls refers to the AI’s “player” object, kind of like “this” in C++). With these two APIs combined, you should be able to do pretty much any AI.

Obviously, there was quite a bit of plumbing in the back-end that needed to go into it all before these could work, and they’re still not the only thing you’ll ever call, but it’s a nice start.

Here’s an example of some Lua from one of the test scripts I’ve written:

So, line 2 of that snippet looks for all “factory” units whose “build_state” is “idle” (that is, all factories that are not currently building anything). The self:find_units function returns a collection of units - you can iterate them and do stuff like that if you like, but we just want to issue them a “build” order to build the “simple-tank” unit type, which is what we do in line 3.

On line 5, we call the self:timer function to schedule ourselves to run again in 10 seconds.

This is the basic way that the AI will be implemented for the initial release. I’m hoping to make the AI interface generic enough that people will feel compelled to write their own AI for the game. Who knows? Maybe we could set up tournaments specifically for the AIs that people have developed!

Aaaaanyway (that was a rather long set up for the rest of my post which is actually pretty to-the-point!), my Word add-in is also WPF and I am using the hosting feature of WinForms to link my VSTO add-in to the WPF controls and so on. So far, it’s been a magical experience, but I ran into a problem when trying to create a “theme” for my app (the default WPF theme is fugly!).

I found this post on Dr. WPF’s blog, and it explained one way to get application-level resources in a hosted environment (you basically just have to create the Application object yourself).

The only problem was that one of the buttons I have in my Ribbon opens a WPF window. If you then closed that window and clicked the button to open it again, you would get the following exception:

The fix was actually on that post that I linked to, but since it was in the comments, way down the bottom, I missed it on my first look. Anyway, the answer was that I had to set the ShutdownMode correctly on the application, like so:

(The fully-qualified type names are required since VSTO has an Application property that was otherwise interfering)

If you don’t set ShutdownMode correctly, the default action is that the first window to be opened is designated as the “main” window, and so when the main window closes, WPF will shut down the Application object as well. By setting it to OnExplicitShutdown, you have to remember to explcitly call Application.Shutdown, but at least we have explicit control over when it happens.

Normally, I’ll read an “introduction” or “getting started” style guide, which will usually get you a basic “hello world” or whatever, and then it’s usually a fairly simple matter of adding functionality to that until I get whatever I was trying to do in the first place.

For example, my recent forays into Lua and Luabind were like that. I started off reading the “Programming in Lua” book, which gave an overview of the language itself, then I used the fantastic Luabind documentation to fill in the gaps of how to integrate it with my game.

Now, I did struggle a bit with one or two things (as you can see my blog post), but for the most part it was exceedingly simple and I was up and running in about 3 days.

But Silverlight has been different. The way I’ve been programming in Silverlight is:

1. Decide what I want to do next
2. Fumble around with the classes, properties and methods I can see in the Intellisense list
3. Give up and google search
4. Find a post on the Silverlight forums, Stack Overflow, or something like that
5. Do whatever it says to get stuff to work
6. Go to step #1

I don’t know if it’s just because the Silverlight framework is so huge (though I never had this problem with Win Forms or ASP.NET, I’m sure) maybe it’s just because in the past, when I’ve started on a new technology, it’s usually been by starting with an existing codebase (that is, when I start a new job), or whether it’s just because Silverlight really is that confusing and inconsistent.

Anyway, I’ll stick with it, and hopefully I’ll have that “aha!” moment when it’ll all start to fall into place and I’m no longer just fumbling around in the dark… we’ll see.