Apr 28

C Enums

Enums in C are something special.  They’re not strongly typed at all.  As it’s pointed out, sometimes enums are used for making bit values, which is rather convenient.  However, it would be very good if enums could be strongly typed.  So, here’s my thought on how to make enums in C better.

Enums should be strongly typed.  The following should throw a compile error about assigning an integer to an enum:

enum MyEnum{ Value1 = 0, Value2 = 1 };
enum MyEnum variable = 0;

However, since this is C, casting should be allowed. So you could do this:

enum MyEnum{ Value1 = 0, Value2 = 1 };
enum MyEnum variable = (enum MyEnum)0;

Now about the bitset. I think that the best way to do this is to create a new enum-like type, called bitfield. It would have a syntax nearly itentical to enum, and the compiler could auto-increment the bitfields as well, so that you can ensure bitfields are always good:

bitfield MyBitfield{ Value1 = 0, Value2 = 1, Value3 = 3, Value4 = Value2 | Value3 };

The compiler would then go through and ensure that all bitfields are valid. You could also put more than one bitfield value into a bitfield, and the compiler would ensure that they’re both of the same type. So, this would be valid:

bitfield MyBitfield{ Value1 = 0, Value2 = 1, Value3 = 3, Value4 = Value2 | Value3 };
bitfield variable = Value1;  /* Works */

/* When passing in a method */
void foo( bitfield parameter ){
  if( parameter & Value2 ){
    /* Do something */
  }
}

This would create a much more type-safe form of enums for C. While not backwards-compatible, it’s not a dramatic shift in how enums are used, so it wouldn’t require huge changes.

Apr 18

Software Licences

So I came across this article via Slashdot today, and I figured that I’d post some thoughts on my programming utils and their license.

The part that I really noticed was:

…younger developers may be choosing more permissive licenses as a way of pushing back against what they see as a “permission culture.” They prefer to let other developers just do whatever they want with their code – and, rightly or wrongly, this might be a reason why many projects are released with no license whatsoever.

This is basically what I was going for.  I don’t care what people use my software for.  It is there for people to use.  In that regard, the WTFPL may be a better choice, but I’m comfortable enough with the MIT license.  As long as proper credit is given, that is good enough for me.  The code is released in the hope that it will make other people’s lives easier.

Apr 03

Auto-generation of environments

So I’ve been re-playing GTAIII lately, and I thought of something.  How would one make a full city, with full interiors for every building that is there?  Couldn’t we just generate all this stuff at run-time?

This makes a lot of sense.  The code size becomes larger, but the code size is generally pretty insignificant compared to the size of the assets of the game.  If we define basic things such as how things go together, we could get something cool here.  For example, an office environment could have desks and chairs, and chairs should normally be next to desks.  Cubicle walls follow the same general footprint.  You don’t even need to randomly generate these things per-se; in order for everybody to have the same room, just have a function call which takes an int as an argument all the time; like a pseudo-random number generator, you’d get the same output every time that you ran it.  Ideally, what you would have is each floor of a building being a certain input to this generator of floors.  You don’t need to run through the code to generate the floor unless the player actually goes up to the floor. The environment artist also doesn’t have to create the floor at all, all he would have to do is to say “Okay, these are the floor dimensions. Here is the number.  Generate!” and it would do it.

It could work.  I’m not going to try and implement this, because it’s probably hard and I don’t really have anything to use it for anyway.  But it could be cool.