It might seem like a small thing but a huge milestone I’ve hit recently is getting a full tool chain running patched gcc-4.1 and gdb-6.5 with D support. Here’s a sample call stack from a crasher I’m investigating in phobos. Notice that it has the correct line numbers and all the D symbols are correctly demanged. This isn’t the case if I use stock dmd or gdb.

Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread -1211786352 (LWP 19585)]
0xb7dcccbc in memcpy () from /lib/tls/i686/cmov/libc.so.6
(gdb) bt
#0  0xb7dcccbc in memcpy () from /lib/tls/i686/cmov/libc.so.6
#1  0x0805ac8e in _adDupT (ti=@0x806381c, a={length = 134815743, ptr = 0xb7c72c1f})
    at ../.././libphobos/internal/gc/gc.d:1045
#2  0x08055a25 in std.stdio.readln(std.c.stdio._iobuf*, inout char[]) (fp=0xb7ea1440, buf=@0xb7c5932c) at ../.././libphobos/std/stdio.d:447
#3  0x08055aaa in std.stdio.readln(std.c.stdio._iobuf*) (fp=0xb7ea1440)
    at ../.././libphobos/std/stdio.d:281
#4  0x0804a218 in main.ConsoleThread.run() (this=@0xb7c5bb00) at main.d:37
#5  0x08053620 in std.thread.Thread.threadstart() (p=0xb7c5bb00)
    at ../.././libphobos/std/thread.d:988
#6  0xb7eaa46b in start_thread () from /lib/tls/i686/cmov/libpthread.so.0
#7  0xb7e2e6de in clone () from /lib/tls/i686/cmov/libc.so.6
(gdb) 

I was interviewed with 3 other programmers for an IGN Vault piece this week. They  asked us to describe some of the challenges we had to overcome to ship the game. It was nice to be able to talk about some of the technology behind the game publicly. After ship I’d like to go into more detail on what we’re doing server-side, within limits unfortunately  Today I’ll be participating with the rest of the team in the Kill General British event. You can find me in Valverde Plateau as General Britsauce. Beware of my mad genadier PKing skillz!

The DSL that I’m using is pretty small right now, which lends itself to easier understanding and explanation.

Ruby code tarball can be downloaded here.

A FSM is defined in a ruby script file without any class definition using the following rules:

1. All attributes are specified in a method named ‘setup’. Setup takes an argument hash which may contain arguments that can be used to setup a FSM entity.
2. All states are specified by defining top level methods with the name ‘while<statename>’. These methods are called in a tick update while that state is active.
3. All transitions are initiated by saying start :statename

def whileidle

target_nearest

start :chasing if @target

end

World#load uses the Object#instance_eval method to evaluate the contents of the FSM definition in terms of a FSM base instance. The FSM class defines some methods that can be called within the FSM definition to control state transitions and to access common methods.

Practically speak this is a very simple way to enable easy extension of a system. It provides an easier path to refactor the individual state machines and lowers the barrier to entry for writing state machine code. Additionally, it would be nice to include certain types of behavior from modules so that state machine authors could have easy access to some of the methods currently defined in creature FSM. This would include methods like target_nearest.  You could also mix in native C modules to get access to things like a path finding grid.

Ideas for playing with the code:

1. Make creatures pick up the ‘ammo’ entities
2. Make creatures compete for the ‘fark’ entities
3. Add a new term to the FSM for state transitions. The method names should be named ‘whenchangingfrom<statename>, whenchangingto<statename>, whenchangingfrom<statename>to_<statename>’ and should be executed when those state change patterns are matched.
4. Allow entities to die

A great article about some of the different types of DSL creation and the mindset from one of the coders at 37signals:

http://weblog.jamisbuck.org/2006/4/20/writing-domain-specific-languages

Careful of using missing_method, it bit me in the arse a number of times:

http://redhanded.hobix.com/inspect/theBestOfMethod_missing.html

It’s really hard to track down bugs related to methodmissing, any code you write inside an object implementing this needs to be carefully checked. It can also lead to blowing your stack when an error in methodmissing recalls method_missing.. and on and on.

This little gem is nice to keep in your back pocket when trying to raise a descriptive exception:

http://blog.nicksieger.com/articles/2006/09/06/rubys-exception-hierarchy

It’s not very complex and it doesn’t do any culling currently because I didn’t find that to be a problem given the ammount of terrain samples that I’m rendering. I generally spend most of my time on the game play first before tweaking the graphics engine.

Here is the code used for generating and rendering the terrain in the screenshots:

http://jrepp.com/code/Terrain.cs

The method used is as follows:

Given a grid of height samples

1. For some number N
2. Choose a random X,Y sample in the grid
3. Write a random value into the sample
4. Blend that sample with all adjacent samples recursively

The verts are colored to get the basic effect of having land and sea.

Overall it’s a pretty simple algorithm that produces fairly decent looking results.

Please let me know if you have any questions, I’ll be happy to answer them.

Now granted this isn’t Gamespy, IGN or 1up but that’s a good thing. I have been reading kotaku for a few years now and I respect their opinion on games. They haven’t had back stage access or been flown out to Austin to check out the game so this is based solely on their E3 impression.

Brent if you’re reading this congrats on Mass Effect, I can’t wait to play it. Hope Canada is treating you well

The sources in the distribution and on trunk can be built for Mac OS X for anyone who would like to experiment on that platform. Window start up time on my dual G5 is a bit slow for my tastes and I haven’t gotten in to optimize it yet.

I would like to thank basaah for his great suggestions and feedback on the 0.1.1 release.

I feel the code structure is straining a bit now that I’m starting to add in new objects.  It’s not terribly hard to add new functionality but the code base is definitely much larger than it was when I first threw this together as a proof of concept.

I’m going to do a dot release to document sprites and flush out the functionality. I’d love to get more feedback from anyone using RubyCube as to what you would like to see to make it more useful.

Since documentation is not yet ready for sprites the best way to see the API is in the new test/testsprite.rb driver.

• Download available here
• Updated docs available here

RubyCube 0.1.1

I’m in the process of getting a new ruby forge project setup to host the project files, mirror the source depot and manage bugs.

I’m very happy with the overall quality of this initial release.

Incidentally, I also uploaded a copy of my async IO extension to ruby forge.

It takes some serious hardware to fight dragons, don’t go into a dragon fight without taking at least some of the following:

GlowCode, gprof, ElectricFence, LOP/F1 Profiler, BoundsChecker, ValGrind, dbghelp.lib, VLD

I put GlowCode at the front of the list intentionally. I just downloaded it but this thing is the excalibur of dragon slaying tools.

GlowCode is a great developer tool, it might look a little crufty but all the little interface issues are thought through and the thing is just fast and does everything you want right how you want it. I quickly found a number of hot spots in the game and immediately went to take a nap (no sense fighting a dragon while tired right?)

Out of curiosity I profiled the RubyCube stress test and timefree() was using about 50% of the total time, this is the internal ruby hook that returns a Time object to the heap. Of the other time 70% was spent in gshape_render() which is the function that renders a single shape. So again, this especially outlines the need to use an alternative timing mechanism in RubyCube. Exclusive time gives a good indication of what routines are doing the most actual work but often times looking at average or total Exclusive+Inclusive time can give you a good idea of where you might find some low hanging fruit.

All of the other tests are running well. One more documentation pass and I’ll be ready to do a windows release. I want to follow that closely with the mac release. To get things running on the mac should be as simple as:

1. Replace Win32 threads with pthreads (nothing fancy, just conditional compilation)
2. Ditto for the critical sections migrating to pthread mutexes.
3. Some cross platform glue sniffing in extconf.rb will be needed as well.

Having the test cases has been instrumental in making any progress. I keep the build stable between work sessions and focus all my work around achieving results in a test case. A lot of bugs and usability issues have been fixed already using this method. I added a couple big handfuls of useful functionality as a result.

As an example two new global methods ‘pause’ and ‘resume’ were added to allow me to control the animation test more explicitly. This is actually a really simple feature that is fun to play with.

Also as a result of this type of work I converted to using array tuples for vector arguments. This has made the ruby code more readable and allows an easier transition from 2D to 3D.

Timers are another big example, without the stress test I never would have seen the timer GC thrashing and decided to implement a timer event.

XNA BM Font rendering code