At the risk of starting another flame war, I would say some form of templates could be very useful. C++-like templates.

Generics are all fine and dandy when it comes to containers, but beyond those, they quickly become quite messy & unwieldy. Also they favor bloat-ware/code complexity on the generated binary, which isn't very desirable for games.

For games, the downsides of templates (weird, hard to understand compile-time errors) would matter much less than their benefits.

For those that don't know the difference, it can be summarized by saying that a generic can be syntax-checked on its own (outside of any specialization), while a template is closer to a macro, that is syntax-checked on specialization.

For instance, suppose you want to add two "things", with templates, you can write just:

Code:
function Add<T>(a, b : T) : T;
begin
   Result := a + b
end;
It'll work for Integer, String, Double, or anything for which you overloaded the + operator (like vector records/static arrays).
And you'll get an error for things that don't support the + operator, like Add<Boolean>.

But it won't work for generics, as a generic type T can't always be added... so you'll get a compile-time error on the generic.
To make it work, you have to add an interface and a constraint:

Code:
type IAddable<T> = interface
   function Add(b : T) : T;
end;

function Add<T : IAddable<T>>(a, b : T) : T;
begin
   Result := a.Add( b );
end;
but then it'll only work for generic classes that implement the generic IAddable interface, it won't work for simple types, records or arrays unless you box them.

It also makes a simple generic sorter a creation of hideous complexity, as you'll need a generic IComparer<T> (cf. the RTL source...), while writing a template-based sorter can be trivial. Same goes for most algorithms. Soon enough, you find yourself piling up generic interfaces.

Now, all isn't rosy with templates, as templates can use other templates, so it's possible to get at the specialization errors that relate to a sub-sub-sub-template of the template you're using, with an error message that can be eminently cryptic because it bears only very indirect relation to what you were trying to do.